version = (1, 1)

data = ({'kAISEnvFacade': 972,
  'kAddDoubleLinear': 5,
  'kAdskMaterial': 1060,
  'kAffect': 6,
  'kAimConstraint': 111,
  'kAir': 257,
  'kAlignCurve': 41,
  'kAlignManip': 907,
  'kAlignSurface': 42,
  'kAmbientLight': 303,
  'kAngle': 270,
  'kAngleBetween': 21,
  'kAnimBlend': 789,
  'kAnimBlendInOut': 790,
  'kAnimCurve': 7,
  'kAnimCurveTimeToAngular': 8,
  'kAnimCurveTimeToDistance': 9,
  'kAnimCurveTimeToTime': 10,
  'kAnimCurveTimeToUnitless': 11,
  'kAnimCurveUnitlessToAngular': 12,
  'kAnimCurveUnitlessToDistance': 13,
  'kAnimCurveUnitlessToTime': 14,
  'kAnimCurveUnitlessToUnitless': 15,
  'kAnimLayer': 1013,
  'kAnisotropy': 617,
  'kAnnotation': 271,
  'kAnyGeometryVarGroup': 115,
  'kArcLength': 273,
  'kAreaLight': 305,
  'kArrayMapper': 524,
  'kArrowManip': 123,
  'kArubaTesselate': 1124,
  'kAssembly': 1074,
  'kAsset': 1011,
  'kAttachCurve': 43,
  'kAttachSurface': 44,
  'kAttribute': 561,
  'kAttribute2Double': 742,
  'kAttribute2Float': 743,
  'kAttribute2Int': 745,
  'kAttribute2Long': 745,
  'kAttribute2Short': 744,
  'kAttribute3Double': 746,
  'kAttribute3Float': 747,
  'kAttribute3Int': 749,
  'kAttribute3Long': 749,
  'kAttribute3Short': 748,
  'kAttribute4Double': 875,
  'kAudio': 22,
  'kAverageCurveManip': 149,
  'kAvgCurves': 45,
  'kAvgNurbsSurfacePoints': 47,
  'kAvgSurfacePoints': 46,
  'kAxesActionManip': 124,
  'kBackground': 23,
  'kBallProjectionManip': 125,
  'kBarnDoorManip': 150,
  'kBase': 1,
  'kBaseLattice': 249,
  'kBendLattice': 335,
  'kBevel': 48,
  'kBevelManip': 151,
  'kBevelPlus': 894,
  'kBezierCurve': 1047,
  'kBezierCurveData': 1048,
  'kBezierCurveToNurbs': 1050,
  'kBinaryData': 741,
  'kBirailSrf': 49,
  'kBlend': 27,
  'kBlendColorSet': 734,
  'kBlendColors': 31,
  'kBlendDevice': 30,
  'kBlendManip': 152,
  'kBlendNodeAdditiveRotation': 1026,
  'kBlendNodeAdditiveScale': 1025,
  'kBlendNodeBase': 1014,
  'kBlendNodeBoolean': 1015,
  'kBlendNodeDouble': 1016,
  'kBlendNodeDoubleAngle': 1017,
  'kBlendNodeDoubleLinear': 1018,
  'kBlendNodeEnum': 1019,
  'kBlendNodeFloat': 1020,
  'kBlendNodeFloatAngle': 1021,
  'kBlendNodeFloatLinear': 1022,
  'kBlendNodeInt16': 1023,
  'kBlendNodeInt32': 1024,
  'kBlendNodeTime': 1045,
  'kBlendShape': 336,
  'kBlendTwoAttr': 28,
  'kBlendWeighted': 29,
  'kBlindData': 751,
  'kBlindDataTemplate': 752,
  'kBlinn': 371,
  'kBlinnMaterial': 386,
  'kBoundary': 53,
  'kBox': 862,
  'kBoxData': 861,
  'kBrownian': 504,
  'kBrush': 760,
  'kBulge': 493,
  'kBulgeLattice': 338,
  'kBump': 32,
  'kBump3d': 33,
  'kButtonManip': 153,
  'kCacheBase': 992,
  'kCacheBlend': 993,
  'kCacheFile': 982,
  'kCacheTrack': 994,
  'kCacheableNode': 989,
  'kCaddyManipBase': 1103,
  'kCamera': 250,
  'kCameraManip': 154,
  'kCameraPlaneManip': 143,
  'kCameraSet': 1004,
  'kCameraView': 34,
  'kCenterManip': 134,
  'kChainToSpline': 35,
  'kCharacter': 683,
  'kCharacterMap': 798,
  'kCharacterMappingData': 737,
  'kCharacterOffset': 684,
  'kChecker': 494,
  'kChoice': 36,
  'kChooser': 767,
  'kCircle': 54,
  'kCircleManip': 126,
  'kCirclePointManip': 231,
  'kCircleSweepManip': 128,
  'kClampColor': 39,
  'kClientDevice': 1070,
  'kClip': 804,
  'kClipGhostShape': 1075,
  'kClipLibrary': 775,
  'kClipScheduler': 774,
  'kClipToGhostData': 1076,
  'kCloseCurve': 55,
  'kCloseSurface': 57,
  'kClosestPointOnMesh': 984,
  'kClosestPointOnSurface': 56,
  'kCloth': 495,
  'kCloud': 505,
  'kCluster': 251,
  'kClusterFilter': 347,
  'kClusterFlexor': 300,
  'kCoiManip': 155,
  'kCollision': 253,
  'kColorBackground': 24,
  'kColorMgtGlobals': 1094,
  'kColorProfile': 1059,
  'kCombinationShape': 337,
  'kCommCornerManip': 608,
  'kCommCornerOperManip': 609,
  'kCommEdgeOperManip': 606,
  'kCommEdgePtManip': 605,
  'kCommEdgeSegmentManip': 607,
  'kComponent': 531,
  'kComponentListData': 579,
  'kComponentManip': 669,
  'kCompoundAttribute': 571,
  'kConcentricProjectionManip': 129,
  'kCondition': 37,
  'kCone': 96,
  'kConstraint': 927,
  'kContainer': 1006,
  'kContainerBase': 1061,
  'kContourProjectionManip': 1108,
  'kContrast': 38,
  'kControl': 482,
  'kControllerTag': 1121,
  'kCopyColorSet': 733,
  'kCopyUVSet': 802,
  'kCpManip': 156,
  'kCrater': 506,
  'kCreaseSet': 1083,
  'kCreate': 40,
  'kCreateBPManip': 832,
  'kCreateBezierManip': 1046,
  'kCreateCVManip': 157,
  'kCreateColorSet': 731,
  'kCreateEPManip': 158,
  'kCreateSectionManip': 819,
  'kCreateUVSet': 803,
  'kCrossSectionEditManip': 820,
  'kCrossSectionManager': 818,
  'kCubicProjectionManip': 130,
  'kCurve': 266,
  'kCurveCVComponent': 532,
  'kCurveCurveIntersect': 636,
  'kCurveEPComponent': 533,
  'kCurveEdManip': 159,
  'kCurveFromMeshCoM': 929,
  'kCurveFromMeshEdge': 635,
  'kCurveFromSubdivEdge': 831,
  'kCurveFromSubdivFace': 837,
  'kCurveFromSurface': 58,
  'kCurveFromSurfaceBnd': 59,
  'kCurveFromSurfaceCoS': 60,
  'kCurveFromSurfaceIso': 61,
  'kCurveInfo': 62,
  'kCurveKnotComponent': 534,
  'kCurveNormalizerAngle': 996,
  'kCurveNormalizerLinear': 997,
  'kCurveParamComponent': 535,
  'kCurveSegmentManip': 160,
  'kCurveVarGroup': 116,
  'kCustomEvaluatorClusterNode': 1122,
  'kCylinder': 98,
  'kCylindricalProjectionManip': 131,
  'kDOF': 323,
  'kDPbirailSrf': 50,
  'kDagContainer': 1062,
  'kDagNode': 107,
  'kDagPose': 685,
  'kDagSelectionItem': 558,
  'kData': 578,
  'kData2Double': 588,
  'kData2Float': 589,
  'kData2Int': 590,
  'kData2Long': 590,
  'kData2Short': 591,
  'kData3Double': 592,
  'kData3Float': 593,
  'kData3Int': 594,
  'kData3Long': 594,
  'kData3Short': 595,
  'kData4Double': 876,
  'kDblTrsManip': 190,
  'kDecayRegionCapComponent': 544,
  'kDecayRegionComponent': 545,
  'kDefaultLightList': 317,
  'kDeformBend': 620,
  'kDeformBendManip': 626,
  'kDeformFlare': 623,
  'kDeformFlareManip': 629,
  'kDeformFunc': 619,
  'kDeformSine': 624,
  'kDeformSineManip': 630,
  'kDeformSquash': 622,
  'kDeformSquashManip': 628,
  'kDeformTwist': 621,
  'kDeformTwistManip': 627,
  'kDeformWave': 625,
  'kDeformWaveManip': 631,
  'kDeleteColorSet': 732,
  'kDeleteComponent': 318,
  'kDeleteUVSet': 795,
  'kDeltaMush': 350,
  'kDependencyNode': 4,
  'kDetachCurve': 63,
  'kDetachSurface': 64,
  'kDiffuseMaterial': 384,
  'kDimension': 269,
  'kDimensionManip': 232,
  'kDirectedDisc': 276,
  'kDirectionManip': 161,
  'kDirectionalLight': 308,
  'kDiscManip': 132,
  'kDiskCache': 858,
  'kDispatchCompute': 319,
  'kDisplacementShader': 321,
  'kDisplayLayer': 728,
  'kDisplayLayerManager': 729,
  'kDistance': 272,
  'kDistanceBetween': 322,
  'kDistanceManip': 633,
  'kDofManip': 162,
  'kDoubleAngleAttribute': 563,
  'kDoubleArrayData': 580,
  'kDoubleIndexedComponent': 709,
  'kDoubleLinearAttribute': 565,
  'kDoubleShadingSwitch': 614,
  'kDrag': 258,
  'kDropOffFunction': 821,
  'kDropoffLocator': 282,
  'kDropoffManip': 163,
  'kDummy': 254,
  'kDummyConnectable': 324,
  'kDynAirManip': 719,
  'kDynArrayAttrsData': 724,
  'kDynAttenuationManip': 723,
  'kDynBase': 715,
  'kDynBaseFieldManip': 718,
  'kDynEmitterManip': 716,
  'kDynFieldsManip': 717,
  'kDynGlobals': 764,
  'kDynNewtonManip': 720,
  'kDynParticleSetComponent': 556,
  'kDynSpreadManip': 722,
  'kDynSweptGeometryData': 738,
  'kDynTurbulenceManip': 721,
  'kDynamicConstraint': 986,
  'kDynamicsController': 325,
  'kEdgeComponent': 541,
  'kEditCurve': 816,
  'kEditCurveManip': 817,
  'kEditMetadata': 1082,
  'kEditsManager': 1090,
  'kEmitter': 255,
  'kEnableManip': 136,
  'kEnumAttribute': 568,
  'kEnvBall': 487,
  'kEnvChrome': 489,
  'kEnvCube': 488,
  'kEnvFacade': 971,
  'kEnvFogMaterial': 378,
  'kEnvFogShape': 278,
  'kEnvSky': 490,
  'kEnvSphere': 491,
  'kExplodeNurbsShell': 687,
  'kExpression': 327,
  'kExtendCurve': 65,
  'kExtendCurveDistanceManip': 164,
  'kExtendSurface': 66,
  'kExtendSurfaceDistanceManip': 711,
  'kExtract': 328,
  'kExtrude': 67,
  'kExtrudeManip': 165,
  'kFFD': 339,
  'kFFblendSrf': 68,
  'kFFfilletSrf': 69,
  'kFacade': 969,
  'kFfdDualBase': 340,
  'kField': 256,
  'kFileBackground': 25,
  'kFileTexture': 496,
  'kFilletCurve': 70,
  'kFilter': 329,
  'kFilterClosestSample': 330,
  'kFilterEuler': 331,
  'kFilterSimplify': 332,
  'kFitBspline': 71,
  'kFixedLineManip': 233,
  'kFlexor': 299,
  'kFloatAngleAttribute': 564,
  'kFloatArrayData': 1030,
  'kFloatLinearAttribute': 566,
  'kFloatMatrixAttribute': 575,
  'kFloatVectorArrayData': 1007,
  'kFlow': 72,
  'kFluid': 909,
  'kFluidData': 911,
  'kFluidEmitter': 915,
  'kFluidGeom': 910,
  'kFluidTexture2D': 904,
  'kFluidTexture3D': 903,
  'kFollicle': 930,
  'kForceUpdateManip': 690,
  'kFosterParent': 1085,
  'kFourByFourMatrix': 770,
  'kFractal': 497,
  'kFreePointManip': 133,
  'kFreePointTriadManip': 137,
  'kGammaCorrect': 333,
  'kGenericAttribute': 572,
  'kGeoConnectable': 326,
  'kGeoConnector': 917,
  'kGeomBind': 1093,
  'kGeometric': 265,
  'kGeometryConstraint': 113,
  'kGeometryData': 707,
  'kGeometryFilt': 334,
  'kGeometryOnLineManip': 142,
  'kGeometryVarGroup': 114,
  'kGlobalCacheControls': 857,
  'kGlobalStitch': 696,
  'kGranite': 507,
  'kGravity': 259,
  'kGreasePencilSequence': 1081,
  'kGreasePlane': 1079,
  'kGreasePlaneRenderShape': 1080,
  'kGrid': 498,
  'kGroundPlane': 290,
  'kGroupId': 354,
  'kGroupParts': 355,
  'kGuide': 356,
  'kGuideLine': 301,
  'kHairConstraint': 935,
  'kHairSystem': 931,
  'kHairTubeShader': 942,
  'kHandleRotateManip': 216,
  'kHardenPointCurve': 73,
  'kHardwareReflectionMap': 881,
  'kHardwareRenderGlobals': 523,
  'kHardwareRenderingGlobals': 1064,
  'kHeightField': 916,
  'kHikEffector': 956,
  'kHikFKJoint': 958,
  'kHikFloorContactMarker': 978,
  'kHikGroundPlane': 979,
  'kHikHandle': 960,
  'kHikIKEffector': 957,
  'kHikSolver': 959,
  'kHistorySwitch': 983,
  'kHsvToRgb': 357,
  'kHwShaderNode': 884,
  'kHyperGraphInfo': 358,
  'kHyperLayout': 359,
  'kHyperLayoutDG': 998,
  'kHyperView': 360,
  'kIkEffector': 119,
  'kIkHandle': 120,
  'kIkRPManip': 167,
  'kIkSolver': 361,
  'kIkSplineManip': 166,
  'kIkSystem': 367,
  'kIllustratorCurve': 74,
  'kImageAdd': 654,
  'kImageBlur': 660,
  'kImageColorCorrect': 659,
  'kImageData': 648,
  'kImageDepth': 662,
  'kImageDiff': 655,
  'kImageDisplay': 663,
  'kImageFilter': 661,
  'kImageLoad': 649,
  'kImageMotionBlur': 665,
  'kImageMultiply': 656,
  'kImageNetDest': 652,
  'kImageNetSrc': 651,
  'kImageOver': 657,
  'kImagePlane': 368,
  'kImageRender': 653,
  'kImageSave': 650,
  'kImageSource': 786,
  'kImageUnder': 658,
  'kImageView': 664,
  'kImplicitCone': 889,
  'kImplicitSphere': 890,
  'kInsertKnotCrv': 75,
  'kInsertKnotSrf': 76,
  'kInstancer': 757,
  'kInt64ArrayData': 809,
  'kIntArrayData': 581,
  'kIntersectSurface': 77,
  'kInvalid': 0,
  'kIsoparmComponent': 536,
  'kIsoparmManip': 146,
  'kItemList': 560,
  'kJiggleDeformer': 856,
  'kJoint': 121,
  'kJointCluster': 349,
  'kJointClusterManip': 168,
  'kJointTranslateManip': 229,
  'kKeyframeDelta': 944,
  'kKeyframeDeltaAddRemove': 947,
  'kKeyframeDeltaBlockAddRemove': 948,
  'kKeyframeDeltaBreakdown': 952,
  'kKeyframeDeltaInfType': 949,
  'kKeyframeDeltaMove': 945,
  'kKeyframeDeltaScale': 946,
  'kKeyframeDeltaTangent': 950,
  'kKeyframeDeltaWeighted': 951,
  'kKeyframeRegionManip': 995,
  'kKeyingGroup': 682,
  'kLambert': 369,
  'kLambertMaterial': 385,
  'kLast': 1126,
  'kLattice': 279,
  'kLatticeComponent': 542,
  'kLatticeData': 582,
  'kLatticeGeom': 280,
  'kLayeredShader': 374,
  'kLayeredTexture': 799,
  'kLeastSquares': 376,
  'kLeather': 508,
  'kLight': 302,
  'kLightDataAttribute': 573,
  'kLightFogMaterial': 377,
  'kLightInfo': 375,
  'kLightLink': 763,
  'kLightList': 379,
  'kLightManip': 169,
  'kLightProjectionGeometry': 234,
  'kLightSource': 380,
  'kLightSourceMaterial': 388,
  'kLimitManip': 135,
  'kLineArrowManip': 235,
  'kLineManip': 147,
  'kLineModifier': 973,
  'kLinearLight': 306,
  'kLocator': 281,
  'kLodGroup': 768,
  'kLodThresholds': 766,
  'kLookAt': 112,
  'kLuminance': 381,
  'kMCsolver': 362,
  'kMPbirailSrf': 51,
  'kMakeGroup': 382,
  'kMandelbrot': 1077,
  'kMandelbrot3D': 1078,
  'kManip2DContainer': 192,
  'kManipContainer': 148,
  'kManipulator': 230,
  'kManipulator2D': 205,
  'kManipulator3D': 122,
  'kMarble': 509,
  'kMarker': 283,
  'kMarkerManip': 210,
  'kMaterial': 383,
  'kMaterialFacade': 970,
  'kMaterialInfo': 389,
  'kMatrixAdd': 390,
  'kMatrixArrayData': 598,
  'kMatrixAttribute': 574,
  'kMatrixData': 583,
  'kMatrixFloatData': 667,
  'kMatrixHold': 391,
  'kMatrixMult': 392,
  'kMatrixPass': 393,
  'kMatrixWtAdd': 394,
  'kMembrane': 1031,
  'kMentalRayTexture': 937,
  'kMergeVertsToolManip': 1032,
  'kMesh': 296,
  'kMeshComponent': 546,
  'kMeshData': 584,
  'kMeshEdgeComponent': 547,
  'kMeshFaceVertComponent': 551,
  'kMeshFrEdgeComponent': 549,
  'kMeshGeom': 297,
  'kMeshMapComponent': 812,
  'kMeshPolygonComponent': 548,
  'kMeshVarGroup': 117,
  'kMeshVertComponent': 550,
  'kMeshVtxFaceComponent': 740,
  'kMessageAttribute': 576,
  'kMidModifier': 395,
  'kMidModifierWithMatrix': 396,
  'kModel': 3,
  'kModifyEdgeBaseManip': 833,
  'kModifyEdgeCrvManip': 824,
  'kModifyEdgeManip': 825,
  'kMotionPath': 441,
  'kMotionPathManip': 170,
  'kMountain': 499,
  'kMoveUVShellManip2D': 705,
  'kMoveVertexManip': 758,
  'kMultDoubleLinear': 769,
  'kMultiSubVertexComponent': 554,
  'kMultilisterLight': 443,
  'kMultiplyDivide': 444,
  'kMute': 926,
  'kNBase': 991,
  'kNCloth': 1000,
  'kNComponent': 987,
  'kNId': 1029,
  'kNIdData': 1028,
  'kNLE': 1088,
  'kNObject': 1009,
  'kNObjectData': 1008,
  'kNParticle': 1001,
  'kNRigid': 1002,
  'kNamedObject': 2,
  'kNearestPointOnCurve': 1058,
  'kNewton': 260,
  'kNodeGraphEditorBookmarkInfo': 1111,
  'kNodeGraphEditorBookmarks': 1110,
  'kNodeGraphEditorInfo': 1109,
  'kNoise': 874,
  'kNonAmbientLight': 304,
  'kNonDagSelectionItem': 559,
  'kNonExtendedLight': 307,
  'kNonLinear': 618,
  'kNormalConstraint': 238,
  'kNucleus': 990,
  'kNumericAttribute': 562,
  'kNumericData': 587,
  'kNurbsBoolean': 688,
  'kNurbsCircular2PtArc': 638,
  'kNurbsCircular3PtArc': 637,
  'kNurbsCube': 80,
  'kNurbsCurve': 267,
  'kNurbsCurveData': 586,
  'kNurbsCurveGeom': 268,
  'kNurbsCurveToBezier': 1049,
  'kNurbsPlane': 79,
  'kNurbsSquare': 616,
  'kNurbsSurface': 294,
  'kNurbsSurfaceData': 585,
  'kNurbsSurfaceGeom': 295,
  'kNurbsTesselate': 78,
  'kNurbsToSubdiv': 755,
  'kObjectAttrFilter': 675,
  'kObjectBinFilter': 938,
  'kObjectFilter': 671,
  'kObjectMultiFilter': 672,
  'kObjectNameFilter': 673,
  'kObjectRenderFilter': 676,
  'kObjectScriptFilter': 677,
  'kObjectTypeFilter': 674,
  'kOcean': 870,
  'kOceanDeformer': 1119,
  'kOceanShader': 893,
  'kOffsetCos': 81,
  'kOffsetCosManip': 171,
  'kOffsetCurve': 82,
  'kOffsetCurveManip': 172,
  'kOffsetSurface': 639,
  'kOffsetSurfaceManip': 647,
  'kOldGeometryConstraint': 445,
  'kOpticalFX': 446,
  'kOrientConstraint': 239,
  'kOrientationComponent': 552,
  'kOrientationLocator': 286,
  'kOrientationMarker': 284,
  'kOrthoGrid': 291,
  'kPASolver': 363,
  'kPairBlend': 922,
  'kParamDimension': 275,
  'kParentConstraint': 242,
  'kParticle': 311,
  'kParticleAgeMapper': 447,
  'kParticleCloud': 448,
  'kParticleColorMapper': 449,
  'kParticleIncandecenceMapper': 450,
  'kParticleSamplerInfo': 801,
  'kParticleTransparencyMapper': 451,
  'kPartition': 452,
  'kPassContributionMap': 782,
  'kPfxGeometry': 940,
  'kPfxHair': 941,
  'kPfxToon': 966,
  'kPhong': 372,
  'kPhongExplorer': 373,
  'kPhongMaterial': 387,
  'kPivotComponent': 537,
  'kPivotManip2D': 191,
  'kPlace2dTexture': 453,
  'kPlace3dTexture': 454,
  'kPlanarProjectionManip': 207,
  'kPlanarTrimSrf': 83,
  'kPlane': 288,
  'kPlugin': 577,
  'kPluginBlendShape': 1114,
  'kPluginCameraSet': 1005,
  'kPluginClientDevice': 1071,
  'kPluginConstraintNode': 1010,
  'kPluginData': 596,
  'kPluginDeformerNode': 610,
  'kPluginDependNode': 455,
  'kPluginEmitterNode': 726,
  'kPluginFieldNode': 725,
  'kPluginGeometryData': 762,
  'kPluginGeometryFilter': 1113,
  'kPluginHardwareShader': 885,
  'kPluginHwShaderNode': 886,
  'kPluginIkSolver': 756,
  'kPluginImagePlaneNode': 999,
  'kPluginLocatorNode': 456,
  'kPluginManipContainer': 691,
  'kPluginManipulatorNode': 1027,
  'kPluginMotionPathNode': 442,
  'kPluginObjectSet': 919,
  'kPluginParticleAttributeMapperNode': 1003,
  'kPluginShape': 706,
  'kPluginSkinCluster': 1112,
  'kPluginSpringNode': 727,
  'kPluginThreadedDevice': 1072,
  'kPluginTransformNode': 908,
  'kPlusMinusAverage': 457,
  'kPointArrayData': 597,
  'kPointConstraint': 240,
  'kPointLight': 309,
  'kPointManip': 236,
  'kPointMatrixMult': 458,
  'kPointOnCurveInfo': 84,
  'kPointOnCurveManip': 208,
  'kPointOnLineManip': 211,
  'kPointOnPolyConstraint': 1053,
  'kPointOnSurfaceInfo': 85,
  'kPointOnSurfaceManip': 212,
  'kPoleVectorConstraint': 243,
  'kPolyAppend': 399,
  'kPolyAppendVertex': 791,
  'kPolyArrow': 974,
  'kPolyAutoProj': 846,
  'kPolyAutoProjManip': 962,
  'kPolyAverageVertex': 845,
  'kPolyBevel': 397,
  'kPolyBevel2': 1091,
  'kPolyBevel3': 1095,
  'kPolyBlindData': 753,
  'kPolyBoolOp': 612,
  'kPolyBridgeEdge': 988,
  'kPolyCBoolOp': 1092,
  'kPolyCaddyManip': 1104,
  'kPolyChipOff': 400,
  'kPolyCircularize': 1123,
  'kPolyClean': 1117,
  'kPolyCloseBorder': 401,
  'kPolyCollapseEdge': 402,
  'kPolyCollapseF': 403,
  'kPolyColorDel': 736,
  'kPolyColorMod': 735,
  'kPolyColorPerVertex': 730,
  'kPolyComponentData': 980,
  'kPolyCone': 433,
  'kPolyConnectComponents': 1054,
  'kPolyContourProj': 1107,
  'kPolyCreaseEdge': 954,
  'kPolyCreateFacet': 439,
  'kPolyCreateToolManip': 140,
  'kPolyCreator': 431,
  'kPolyCube': 434,
  'kPolyCut': 896,
  'kPolyCutManip': 900,
  'kPolyCutManipContainer': 899,
  'kPolyCylProj': 404,
  'kPolyCylinder': 435,
  'kPolyDelEdge': 405,
  'kPolyDelFacet': 406,
  'kPolyDelVertex': 407,
  'kPolyDuplicateEdge': 968,
  'kPolyEdgeToCurve': 1012,
  'kPolyEditEdgeFlow': 1084,
  'kPolyExtrudeEdge': 788,
  'kPolyExtrudeFacet': 408,
  'kPolyExtrudeManip': 1067,
  'kPolyExtrudeManipContainer': 1068,
  'kPolyExtrudeVertex': 921,
  'kPolyFlipEdge': 787,
  'kPolyFlipUV': 883,
  'kPolyHelix': 981,
  'kPolyHoleFace': 1052,
  'kPolyLayoutUV': 847,
  'kPolyMapCut': 409,
  'kPolyMapDel': 410,
  'kPolyMapSew': 411,
  'kPolyMapSewMove': 848,
  'kPolyMappingManip': 194,
  'kPolyMergeEdge': 412,
  'kPolyMergeFacet': 413,
  'kPolyMergeUV': 905,
  'kPolyMergeVert': 693,
  'kPolyMesh': 436,
  'kPolyMirror': 953,
  'kPolyMirrorManipContainer': 901,
  'kPolyModifierManip': 195,
  'kPolyModifierManipContainer': 1105,
  'kPolyMoveEdge': 414,
  'kPolyMoveFacet': 415,
  'kPolyMoveFacetUV': 416,
  'kPolyMoveUV': 417,
  'kPolyMoveUVManip': 193,
  'kPolyMoveVertex': 418,
  'kPolyMoveVertexManip': 196,
  'kPolyMoveVertexUV': 419,
  'kPolyNormal': 420,
  'kPolyNormalPerVertex': 754,
  'kPolyNormalizeUV': 882,
  'kPolyPassThru': 1115,
  'kPolyPinUV': 955,
  'kPolyPipe': 977,
  'kPolyPlanProj': 421,
  'kPolyPlatonicSolid': 976,
  'kPolyPoke': 897,
  'kPolyPokeManip': 902,
  'kPolyPrimitive': 432,
  'kPolyPrimitiveMisc': 975,
  'kPolyPrism': 963,
  'kPolyProj': 422,
  'kPolyProjectCurve': 1065,
  'kPolyProjectionManip': 174,
  'kPolyPyramid': 964,
  'kPolyQuad': 423,
  'kPolyReduce': 765,
  'kPolyRemesh': 1106,
  'kPolySelectEditFeedbackManip': 1035,
  'kPolySeparate': 459,
  'kPolySewEdge': 692,
  'kPolySmooth': 424,
  'kPolySmoothFacet': 694,
  'kPolySmoothProxy': 939,
  'kPolySoftEdge': 425,
  'kPolySphProj': 426,
  'kPolySphere': 437,
  'kPolySpinEdge': 1051,
  'kPolySplit': 427,
  'kPolySplitEdge': 810,
  'kPolySplitRing': 965,
  'kPolySplitToolManip': 141,
  'kPolySplitVert': 805,
  'kPolyStraightenUVBorder': 906,
  'kPolySubdEdge': 428,
  'kPolySubdFacet': 429,
  'kPolyToSubdiv': 680,
  'kPolyToolFeedbackManip': 1034,
  'kPolyToolFeedbackShape': 312,
  'kPolyTorus': 438,
  'kPolyTransfer': 844,
  'kPolyTriangulate': 430,
  'kPolyTweak': 398,
  'kPolyTweakUV': 704,
  'kPolyUVRectangle': 1063,
  'kPolyUnite': 440,
  'kPolyVertexNormalManip': 197,
  'kPolyWedgeFace': 898,
  'kPoseInterpolatorManager': 1120,
  'kPositionMarker': 285,
  'kPostProcessList': 460,
  'kPrecompExport': 783,
  'kPrimitive': 86,
  'kProjectCurve': 87,
  'kProjectTangent': 88,
  'kProjectTangentManip': 177,
  'kProjection': 461,
  'kProjectionManip': 173,
  'kProjectionMultiManip': 176,
  'kProjectionUVManip': 175,
  'kPropModManip': 178,
  'kPropMoveTriadManip': 138,
  'kProxWrap': 352,
  'kProxy': 108,
  'kProxyManager': 961,
  'kPsdFileTexture': 943,
  'kQuadPtOnLineManip': 179,
  'kQuadShadingSwitch': 920,
  'kRBFsurface': 89,
  'kRPsolver': 365,
  'kRadial': 261,
  'kRadius': 274,
  'kRamp': 500,
  'kRampBackground': 26,
  'kRampShader': 891,
  'kRbfSrfManip': 180,
  'kRebuildCurve': 90,
  'kRebuildSurface': 91,
  'kRecord': 462,
  'kReference': 750,
  'kReflect': 370,
  'kRemapColor': 933,
  'kRemapHsv': 934,
  'kRemapValue': 932,
  'kRenderBox': 863,
  'kRenderCone': 97,
  'kRenderGlobals': 519,
  'kRenderGlobalsList': 520,
  'kRenderLayer': 780,
  'kRenderLayerManager': 781,
  'kRenderPass': 778,
  'kRenderPassSet': 779,
  'kRenderQuality': 521,
  'kRenderRect': 277,
  'kRenderSetup': 518,
  'kRenderSphere': 298,
  'kRenderTarget': 784,
  'kRenderUtilityList': 463,
  'kRenderedImageSource': 785,
  'kRenderingList': 1066,
  'kReorderUVSet': 1125,
  'kResolution': 522,
  'kResultCurve': 16,
  'kResultCurveTimeToAngular': 17,
  'kResultCurveTimeToDistance': 18,
  'kResultCurveTimeToTime': 19,
  'kResultCurveTimeToUnitless': 20,
  'kReverse': 464,
  'kReverseCrvManip': 182,
  'kReverseCurve': 92,
  'kReverseCurveManip': 181,
  'kReverseSurface': 93,
  'kReverseSurfaceManip': 183,
  'kRevolve': 94,
  'kRevolveManip': 184,
  'kRevolvedPrimitive': 95,
  'kRevolvedPrimitiveManip': 185,
  'kRgbToHsv': 465,
  'kRigid': 314,
  'kRigidConstraint': 313,
  'kRigidDeform': 341,
  'kRigidSolver': 466,
  'kRock': 510,
  'kRotateBoxManip': 214,
  'kRotateLimitsManip': 217,
  'kRotateManip': 215,
  'kRotateUVManip2D': 702,
  'kRoundConstantRadius': 640,
  'kRoundConstantRadiusManip': 643,
  'kRoundRadiusCrvManip': 642,
  'kRoundRadiusManip': 641,
  'kSCsolver': 364,
  'kSPbirailSrf': 52,
  'kSamplerInfo': 474,
  'kScaleConstraint': 244,
  'kScaleLimitsManip': 218,
  'kScaleManip': 219,
  'kScalePointManip': 826,
  'kScaleUVManip2D': 703,
  'kScalingBoxManip': 220,
  'kScreenAlignedCircleManip': 127,
  'kScript': 634,
  'kScriptManip': 221,
  'kSculpt': 342,
  'kSectionManip': 813,
  'kSelectionItem': 557,
  'kSelectionList': 603,
  'kSelectionListData': 670,
  'kSelectionListOperator': 678,
  'kSequenceManager': 1042,
  'kSequencer': 1043,
  'kSet': 467,
  'kSetGroupComponent': 555,
  'kSetRange': 470,
  'kSfRevolveManip': 836,
  'kShaderGlow': 471,
  'kShaderList': 472,
  'kShadingEngine': 320,
  'kShadingMap': 473,
  'kShape': 248,
  'kShapeEditorManager': 1118,
  'kShapeFragment': 475,
  'kShot': 1044,
  'kShrinkWrapFilter': 1089,
  'kSimpleVolumeShader': 476,
  'kSingleIndexedComponent': 708,
  'kSingleShadingSwitch': 613,
  'kSketchPlane': 289,
  'kSkin': 100,
  'kSkinBinding': 1055,
  'kSkinClusterFilter': 681,
  'kSkinShader': 668,
  'kSl60': 477,
  'kSmear': 912,
  'kSmoothCurve': 695,
  'kSmoothTangentSrf': 777,
  'kSnapUVManip2D': 1086,
  'kSnapshot': 478,
  'kSnapshotPath': 918,
  'kSnapshotShape': 854,
  'kSnow': 511,
  'kSoftMod': 252,
  'kSoftModFilter': 348,
  'kSoftModManip': 632,
  'kSolidFractal': 512,
  'kSphere': 99,
  'kSphereData': 599,
  'kSphericalProjectionManip': 222,
  'kSplineSolver': 366,
  'kSpotCylinderManip': 187,
  'kSpotLight': 310,
  'kSpotManip': 186,
  'kSpring': 315,
  'kSprite': 292,
  'kSquareSrf': 712,
  'kSquareSrfManip': 713,
  'kStateManip': 145,
  'kStencil': 501,
  'kStereoCameraMaster': 1041,
  'kStitchAsNurbsShell': 686,
  'kStitchSrf': 101,
  'kStitchSrfManip': 689,
  'kStoryBoard': 479,
  'kStringArrayData': 601,
  'kStringData': 600,
  'kStringShadingSwitch': 913,
  'kStroke': 759,
  'kStrokeGlobals': 761,
  'kStucco': 513,
  'kStudioClearCoat': 914,
  'kStyleCurve': 895,
  'kSubCurve': 102,
  'kSubSurface': 776,
  'kSubVertexComponent': 553,
  'kSubdAddTopology': 887,
  'kSubdAutoProj': 872,
  'kSubdBlindData': 797,
  'kSubdBoolean': 822,
  'kSubdCleanTopology': 888,
  'kSubdCloseBorder': 859,
  'kSubdDelFace': 853,
  'kSubdExtrudeFace': 834,
  'kSubdHierBlind': 796,
  'kSubdLayoutUV': 868,
  'kSubdMapCut': 867,
  'kSubdMapSewMove': 869,
  'kSubdMappingManip': 880,
  'kSubdMergeVert': 860,
  'kSubdModifier': 849,
  'kSubdModifyEdge': 823,
  'kSubdMoveEdge': 851,
  'kSubdMoveFace': 852,
  'kSubdMoveVertex': 850,
  'kSubdPlanProj': 877,
  'kSubdProjectionManip': 879,
  'kSubdSplitFace': 864,
  'kSubdSubdivideFace': 873,
  'kSubdTweak': 878,
  'kSubdTweakUV': 866,
  'kSubdiv': 679,
  'kSubdivCVComponent': 697,
  'kSubdivCollapse': 800,
  'kSubdivCompId': 793,
  'kSubdivData': 806,
  'kSubdivEdgeComponent': 698,
  'kSubdivFaceComponent': 699,
  'kSubdivGeom': 807,
  'kSubdivMapComponent': 855,
  'kSubdivReverseFaces': 811,
  'kSubdivSurfaceVarGroup': 835,
  'kSubdivToNurbs': 815,
  'kSubdivToPoly': 714,
  'kSummaryObject': 480,
  'kSuper': 481,
  'kSurface': 293,
  'kSurfaceCVComponent': 538,
  'kSurfaceEPComponent': 539,
  'kSurfaceEdManip': 772,
  'kSurfaceFaceComponent': 773,
  'kSurfaceInfo': 103,
  'kSurfaceKnotComponent': 540,
  'kSurfaceLuminance': 483,
  'kSurfaceRangeComponent': 543,
  'kSurfaceShader': 484,
  'kSurfaceVarGroup': 118,
  'kSymmetryConstraint': 241,
  'kSymmetryLocator': 828,
  'kSymmetryMapCurve': 830,
  'kSymmetryMapVector': 829,
  'kTangentConstraint': 245,
  'kTension': 351,
  'kTexLattice': 200,
  'kTexLatticeDeformManip': 199,
  'kTexSmoothManip': 201,
  'kTexSmudgeUVManip': 198,
  'kTextButtonManip': 646,
  'kTextCurves': 104,
  'kTextManip': 923,
  'kTexture2d': 492,
  'kTexture3d': 503,
  'kTextureBakeSet': 468,
  'kTextureDeformer': 343,
  'kTextureDeformerHandle': 344,
  'kTextureEnv': 486,
  'kTextureList': 485,
  'kTextureManip3D': 223,
  'kThreadedDevice': 1069,
  'kThreePointArcManip': 644,
  'kTime': 516,
  'kTimeAttribute': 567,
  'kTimeEditor': 1099,
  'kTimeEditorAnimSource': 1102,
  'kTimeEditorClip': 1098,
  'kTimeEditorClipBase': 1096,
  'kTimeEditorClipEvaluator': 1097,
  'kTimeEditorInterpolator': 1101,
  'kTimeEditorTracks': 1100,
  'kTimeFunction': 936,
  'kTimeToUnitConversion': 517,
  'kTimeWarp': 1073,
  'kToggleManip': 224,
  'kToggleOnLineManip': 144,
  'kToolContext': 1087,
  'kToonLineAttributes': 967,
  'kTorus': 611,
  'kTowPointManip': 139,
  'kTowPointOnCurveManip': 209,
  'kTowPointOnSurfaceManip': 771,
  'kTrackInfoManager': 1116,
  'kTransferAttributes': 985,
  'kTransform': 110,
  'kTransformBoxManip': 827,
  'kTransformGeometry': 604,
  'kTranslateBoxManip': 225,
  'kTranslateLimitsManip': 226,
  'kTranslateManip': 227,
  'kTranslateManip2D': 206,
  'kTranslateUVManip': 213,
  'kTranslateUVManip2D': 701,
  'kTriadManip': 237,
  'kTrim': 105,
  'kTrimLocator': 287,
  'kTrimManip': 228,
  'kTrimWithBoundaries': 928,
  'kTriplanarProjectionManip': 188,
  'kTripleIndexedComponent': 710,
  'kTripleShadingSwitch': 615,
  'kTrsInsertManip': 203,
  'kTrsManip': 189,
  'kTrsTransManip': 202,
  'kTrsXformManip': 204,
  'kTurbulence': 262,
  'kTweak': 345,
  'kTwoPointArcManip': 645,
  'kTxSl': 514,
  'kTypedAttribute': 570,
  'kUInt64ArrayData': 808,
  'kUVManip2D': 700,
  'kUint64SingleIndexedComponent': 1033,
  'kUnderWorld': 109,
  'kUniform': 263,
  'kUnitAttribute': 569,
  'kUnitConversion': 525,
  'kUnitToTimeConversion': 526,
  'kUnknown': 528,
  'kUnknownDag': 316,
  'kUnknownTransform': 246,
  'kUntrim': 106,
  'kUnused1': 838,
  'kUnused2': 839,
  'kUnused3': 840,
  'kUnused4': 841,
  'kUnused5': 842,
  'kUnused6': 843,
  'kUseBackground': 527,
  'kUvChooser': 792,
  'kVectorArrayData': 602,
  'kVectorProduct': 529,
  'kVertexBakeSet': 469,
  'kVertexWeightSet': 1057,
  'kViewColorManager': 666,
  'kViewManip': 924,
  'kVolumeAxis': 794,
  'kVolumeBindManip': 1056,
  'kVolumeFog': 865,
  'kVolumeLight': 892,
  'kVolumeNoise': 871,
  'kVolumeShader': 530,
  'kVortex': 264,
  'kWater': 502,
  'kWeightGeometryFilt': 346,
  'kWire': 353,
  'kWood': 515,
  'kWorld': 247,
  'kWrapFilter': 739,
  'kWriteToColorBuffer': 1037,
  'kWriteToDepthBuffer': 1039,
  'kWriteToFrameBuffer': 1036,
  'kWriteToLabelBuffer': 1040,
  'kWriteToVectorBuffer': 1038,
  'kXformManip': 925,
  'kXsectionSubdivEdit': 814},
 {0: 'kInvalid',
  1: 'kBase',
  2: 'kNamedObject',
  3: 'kModel',
  4: 'kDependencyNode',
  5: 'kAddDoubleLinear',
  6: 'kAffect',
  7: 'kAnimCurve',
  8: 'kAnimCurveTimeToAngular',
  9: 'kAnimCurveTimeToDistance',
  10: 'kAnimCurveTimeToTime',
  11: 'kAnimCurveTimeToUnitless',
  12: 'kAnimCurveUnitlessToAngular',
  13: 'kAnimCurveUnitlessToDistance',
  14: 'kAnimCurveUnitlessToTime',
  15: 'kAnimCurveUnitlessToUnitless',
  16: 'kResultCurve',
  17: 'kResultCurveTimeToAngular',
  18: 'kResultCurveTimeToDistance',
  19: 'kResultCurveTimeToTime',
  20: 'kResultCurveTimeToUnitless',
  21: 'kAngleBetween',
  22: 'kAudio',
  23: 'kBackground',
  24: 'kColorBackground',
  25: 'kFileBackground',
  26: 'kRampBackground',
  27: 'kBlend',
  28: 'kBlendTwoAttr',
  29: 'kBlendWeighted',
  30: 'kBlendDevice',
  31: 'kBlendColors',
  32: 'kBump',
  33: 'kBump3d',
  34: 'kCameraView',
  35: 'kChainToSpline',
  36: 'kChoice',
  37: 'kCondition',
  38: 'kContrast',
  39: 'kClampColor',
  40: 'kCreate',
  41: 'kAlignCurve',
  42: 'kAlignSurface',
  43: 'kAttachCurve',
  44: 'kAttachSurface',
  45: 'kAvgCurves',
  46: 'kAvgSurfacePoints',
  47: 'kAvgNurbsSurfacePoints',
  48: 'kBevel',
  49: 'kBirailSrf',
  50: 'kDPbirailSrf',
  51: 'kMPbirailSrf',
  52: 'kSPbirailSrf',
  53: 'kBoundary',
  54: 'kCircle',
  55: 'kCloseCurve',
  56: 'kClosestPointOnSurface',
  57: 'kCloseSurface',
  58: 'kCurveFromSurface',
  59: 'kCurveFromSurfaceBnd',
  60: 'kCurveFromSurfaceCoS',
  61: 'kCurveFromSurfaceIso',
  62: 'kCurveInfo',
  63: 'kDetachCurve',
  64: 'kDetachSurface',
  65: 'kExtendCurve',
  66: 'kExtendSurface',
  67: 'kExtrude',
  68: 'kFFblendSrf',
  69: 'kFFfilletSrf',
  70: 'kFilletCurve',
  71: 'kFitBspline',
  72: 'kFlow',
  73: 'kHardenPointCurve',
  74: 'kIllustratorCurve',
  75: 'kInsertKnotCrv',
  76: 'kInsertKnotSrf',
  77: 'kIntersectSurface',
  78: 'kNurbsTesselate',
  79: 'kNurbsPlane',
  80: 'kNurbsCube',
  81: 'kOffsetCos',
  82: 'kOffsetCurve',
  83: 'kPlanarTrimSrf',
  84: 'kPointOnCurveInfo',
  85: 'kPointOnSurfaceInfo',
  86: 'kPrimitive',
  87: 'kProjectCurve',
  88: 'kProjectTangent',
  89: 'kRBFsurface',
  90: 'kRebuildCurve',
  91: 'kRebuildSurface',
  92: 'kReverseCurve',
  93: 'kReverseSurface',
  94: 'kRevolve',
  95: 'kRevolvedPrimitive',
  96: 'kCone',
  97: 'kRenderCone',
  98: 'kCylinder',
  99: 'kSphere',
  100: 'kSkin',
  101: 'kStitchSrf',
  102: 'kSubCurve',
  103: 'kSurfaceInfo',
  104: 'kTextCurves',
  105: 'kTrim',
  106: 'kUntrim',
  107: 'kDagNode',
  108: 'kProxy',
  109: 'kUnderWorld',
  110: 'kTransform',
  111: 'kAimConstraint',
  112: 'kLookAt',
  113: 'kGeometryConstraint',
  114: 'kGeometryVarGroup',
  115: 'kAnyGeometryVarGroup',
  116: 'kCurveVarGroup',
  117: 'kMeshVarGroup',
  118: 'kSurfaceVarGroup',
  119: 'kIkEffector',
  120: 'kIkHandle',
  121: 'kJoint',
  122: 'kManipulator3D',
  123: 'kArrowManip',
  124: 'kAxesActionManip',
  125: 'kBallProjectionManip',
  126: 'kCircleManip',
  127: 'kScreenAlignedCircleManip',
  128: 'kCircleSweepManip',
  129: 'kConcentricProjectionManip',
  130: 'kCubicProjectionManip',
  131: 'kCylindricalProjectionManip',
  132: 'kDiscManip',
  133: 'kFreePointManip',
  134: 'kCenterManip',
  135: 'kLimitManip',
  136: 'kEnableManip',
  137: 'kFreePointTriadManip',
  138: 'kPropMoveTriadManip',
  139: 'kTowPointManip',
  140: 'kPolyCreateToolManip',
  141: 'kPolySplitToolManip',
  142: 'kGeometryOnLineManip',
  143: 'kCameraPlaneManip',
  144: 'kToggleOnLineManip',
  145: 'kStateManip',
  146: 'kIsoparmManip',
  147: 'kLineManip',
  148: 'kManipContainer',
  149: 'kAverageCurveManip',
  150: 'kBarnDoorManip',
  151: 'kBevelManip',
  152: 'kBlendManip',
  153: 'kButtonManip',
  154: 'kCameraManip',
  155: 'kCoiManip',
  156: 'kCpManip',
  157: 'kCreateCVManip',
  158: 'kCreateEPManip',
  159: 'kCurveEdManip',
  160: 'kCurveSegmentManip',
  161: 'kDirectionManip',
  162: 'kDofManip',
  163: 'kDropoffManip',
  164: 'kExtendCurveDistanceManip',
  165: 'kExtrudeManip',
  166: 'kIkSplineManip',
  167: 'kIkRPManip',
  168: 'kJointClusterManip',
  169: 'kLightManip',
  170: 'kMotionPathManip',
  171: 'kOffsetCosManip',
  172: 'kOffsetCurveManip',
  173: 'kProjectionManip',
  174: 'kPolyProjectionManip',
  175: 'kProjectionUVManip',
  176: 'kProjectionMultiManip',
  177: 'kProjectTangentManip',
  178: 'kPropModManip',
  179: 'kQuadPtOnLineManip',
  180: 'kRbfSrfManip',
  181: 'kReverseCurveManip',
  182: 'kReverseCrvManip',
  183: 'kReverseSurfaceManip',
  184: 'kRevolveManip',
  185: 'kRevolvedPrimitiveManip',
  186: 'kSpotManip',
  187: 'kSpotCylinderManip',
  188: 'kTriplanarProjectionManip',
  189: 'kTrsManip',
  190: 'kDblTrsManip',
  191: 'kPivotManip2D',
  192: 'kManip2DContainer',
  193: 'kPolyMoveUVManip',
  194: 'kPolyMappingManip',
  195: 'kPolyModifierManip',
  196: 'kPolyMoveVertexManip',
  197: 'kPolyVertexNormalManip',
  198: 'kTexSmudgeUVManip',
  199: 'kTexLatticeDeformManip',
  200: 'kTexLattice',
  201: 'kTexSmoothManip',
  202: 'kTrsTransManip',
  203: 'kTrsInsertManip',
  204: 'kTrsXformManip',
  205: 'kManipulator2D',
  206: 'kTranslateManip2D',
  207: 'kPlanarProjectionManip',
  208: 'kPointOnCurveManip',
  209: 'kTowPointOnCurveManip',
  210: 'kMarkerManip',
  211: 'kPointOnLineManip',
  212: 'kPointOnSurfaceManip',
  213: 'kTranslateUVManip',
  214: 'kRotateBoxManip',
  215: 'kRotateManip',
  216: 'kHandleRotateManip',
  217: 'kRotateLimitsManip',
  218: 'kScaleLimitsManip',
  219: 'kScaleManip',
  220: 'kScalingBoxManip',
  221: 'kScriptManip',
  222: 'kSphericalProjectionManip',
  223: 'kTextureManip3D',
  224: 'kToggleManip',
  225: 'kTranslateBoxManip',
  226: 'kTranslateLimitsManip',
  227: 'kTranslateManip',
  228: 'kTrimManip',
  229: 'kJointTranslateManip',
  230: 'kManipulator',
  231: 'kCirclePointManip',
  232: 'kDimensionManip',
  233: 'kFixedLineManip',
  234: 'kLightProjectionGeometry',
  235: 'kLineArrowManip',
  236: 'kPointManip',
  237: 'kTriadManip',
  238: 'kNormalConstraint',
  239: 'kOrientConstraint',
  240: 'kPointConstraint',
  241: 'kSymmetryConstraint',
  242: 'kParentConstraint',
  243: 'kPoleVectorConstraint',
  244: 'kScaleConstraint',
  245: 'kTangentConstraint',
  246: 'kUnknownTransform',
  247: 'kWorld',
  248: 'kShape',
  249: 'kBaseLattice',
  250: 'kCamera',
  251: 'kCluster',
  252: 'kSoftMod',
  253: 'kCollision',
  254: 'kDummy',
  255: 'kEmitter',
  256: 'kField',
  257: 'kAir',
  258: 'kDrag',
  259: 'kGravity',
  260: 'kNewton',
  261: 'kRadial',
  262: 'kTurbulence',
  263: 'kUniform',
  264: 'kVortex',
  265: 'kGeometric',
  266: 'kCurve',
  267: 'kNurbsCurve',
  268: 'kNurbsCurveGeom',
  269: 'kDimension',
  270: 'kAngle',
  271: 'kAnnotation',
  272: 'kDistance',
  273: 'kArcLength',
  274: 'kRadius',
  275: 'kParamDimension',
  276: 'kDirectedDisc',
  277: 'kRenderRect',
  278: 'kEnvFogShape',
  279: 'kLattice',
  280: 'kLatticeGeom',
  281: 'kLocator',
  282: 'kDropoffLocator',
  283: 'kMarker',
  284: 'kOrientationMarker',
  285: 'kPositionMarker',
  286: 'kOrientationLocator',
  287: 'kTrimLocator',
  288: 'kPlane',
  289: 'kSketchPlane',
  290: 'kGroundPlane',
  291: 'kOrthoGrid',
  292: 'kSprite',
  293: 'kSurface',
  294: 'kNurbsSurface',
  295: 'kNurbsSurfaceGeom',
  296: 'kMesh',
  297: 'kMeshGeom',
  298: 'kRenderSphere',
  299: 'kFlexor',
  300: 'kClusterFlexor',
  301: 'kGuideLine',
  302: 'kLight',
  303: 'kAmbientLight',
  304: 'kNonAmbientLight',
  305: 'kAreaLight',
  306: 'kLinearLight',
  307: 'kNonExtendedLight',
  308: 'kDirectionalLight',
  309: 'kPointLight',
  310: 'kSpotLight',
  311: 'kParticle',
  312: 'kPolyToolFeedbackShape',
  313: 'kRigidConstraint',
  314: 'kRigid',
  315: 'kSpring',
  316: 'kUnknownDag',
  317: 'kDefaultLightList',
  318: 'kDeleteComponent',
  319: 'kDispatchCompute',
  320: 'kShadingEngine',
  321: 'kDisplacementShader',
  322: 'kDistanceBetween',
  323: 'kDOF',
  324: 'kDummyConnectable',
  325: 'kDynamicsController',
  326: 'kGeoConnectable',
  327: 'kExpression',
  328: 'kExtract',
  329: 'kFilter',
  330: 'kFilterClosestSample',
  331: 'kFilterEuler',
  332: 'kFilterSimplify',
  333: 'kGammaCorrect',
  334: 'kGeometryFilt',
  335: 'kBendLattice',
  336: 'kBlendShape',
  337: 'kCombinationShape',
  338: 'kBulgeLattice',
  339: 'kFFD',
  340: 'kFfdDualBase',
  341: 'kRigidDeform',
  342: 'kSculpt',
  343: 'kTextureDeformer',
  344: 'kTextureDeformerHandle',
  345: 'kTweak',
  346: 'kWeightGeometryFilt',
  347: 'kClusterFilter',
  348: 'kSoftModFilter',
  349: 'kJointCluster',
  350: 'kDeltaMush',
  351: 'kTension',
  352: 'kProxWrap',
  353: 'kWire',
  354: 'kGroupId',
  355: 'kGroupParts',
  356: 'kGuide',
  357: 'kHsvToRgb',
  358: 'kHyperGraphInfo',
  359: 'kHyperLayout',
  360: 'kHyperView',
  361: 'kIkSolver',
  362: 'kMCsolver',
  363: 'kPASolver',
  364: 'kSCsolver',
  365: 'kRPsolver',
  366: 'kSplineSolver',
  367: 'kIkSystem',
  368: 'kImagePlane',
  369: 'kLambert',
  370: 'kReflect',
  371: 'kBlinn',
  372: 'kPhong',
  373: 'kPhongExplorer',
  374: 'kLayeredShader',
  375: 'kLightInfo',
  376: 'kLeastSquares',
  377: 'kLightFogMaterial',
  378: 'kEnvFogMaterial',
  379: 'kLightList',
  380: 'kLightSource',
  381: 'kLuminance',
  382: 'kMakeGroup',
  383: 'kMaterial',
  384: 'kDiffuseMaterial',
  385: 'kLambertMaterial',
  386: 'kBlinnMaterial',
  387: 'kPhongMaterial',
  388: 'kLightSourceMaterial',
  389: 'kMaterialInfo',
  390: 'kMatrixAdd',
  391: 'kMatrixHold',
  392: 'kMatrixMult',
  393: 'kMatrixPass',
  394: 'kMatrixWtAdd',
  395: 'kMidModifier',
  396: 'kMidModifierWithMatrix',
  397: 'kPolyBevel',
  398: 'kPolyTweak',
  399: 'kPolyAppend',
  400: 'kPolyChipOff',
  401: 'kPolyCloseBorder',
  402: 'kPolyCollapseEdge',
  403: 'kPolyCollapseF',
  404: 'kPolyCylProj',
  405: 'kPolyDelEdge',
  406: 'kPolyDelFacet',
  407: 'kPolyDelVertex',
  408: 'kPolyExtrudeFacet',
  409: 'kPolyMapCut',
  410: 'kPolyMapDel',
  411: 'kPolyMapSew',
  412: 'kPolyMergeEdge',
  413: 'kPolyMergeFacet',
  414: 'kPolyMoveEdge',
  415: 'kPolyMoveFacet',
  416: 'kPolyMoveFacetUV',
  417: 'kPolyMoveUV',
  418: 'kPolyMoveVertex',
  419: 'kPolyMoveVertexUV',
  420: 'kPolyNormal',
  421: 'kPolyPlanProj',
  422: 'kPolyProj',
  423: 'kPolyQuad',
  424: 'kPolySmooth',
  425: 'kPolySoftEdge',
  426: 'kPolySphProj',
  427: 'kPolySplit',
  428: 'kPolySubdEdge',
  429: 'kPolySubdFacet',
  430: 'kPolyTriangulate',
  431: 'kPolyCreator',
  432: 'kPolyPrimitive',
  433: 'kPolyCone',
  434: 'kPolyCube',
  435: 'kPolyCylinder',
  436: 'kPolyMesh',
  437: 'kPolySphere',
  438: 'kPolyTorus',
  439: 'kPolyCreateFacet',
  440: 'kPolyUnite',
  441: 'kMotionPath',
  442: 'kPluginMotionPathNode',
  443: 'kMultilisterLight',
  444: 'kMultiplyDivide',
  445: 'kOldGeometryConstraint',
  446: 'kOpticalFX',
  447: 'kParticleAgeMapper',
  448: 'kParticleCloud',
  449: 'kParticleColorMapper',
  450: 'kParticleIncandecenceMapper',
  451: 'kParticleTransparencyMapper',
  452: 'kPartition',
  453: 'kPlace2dTexture',
  454: 'kPlace3dTexture',
  455: 'kPluginDependNode',
  456: 'kPluginLocatorNode',
  457: 'kPlusMinusAverage',
  458: 'kPointMatrixMult',
  459: 'kPolySeparate',
  460: 'kPostProcessList',
  461: 'kProjection',
  462: 'kRecord',
  463: 'kRenderUtilityList',
  464: 'kReverse',
  465: 'kRgbToHsv',
  466: 'kRigidSolver',
  467: 'kSet',
  468: 'kTextureBakeSet',
  469: 'kVertexBakeSet',
  470: 'kSetRange',
  471: 'kShaderGlow',
  472: 'kShaderList',
  473: 'kShadingMap',
  474: 'kSamplerInfo',
  475: 'kShapeFragment',
  476: 'kSimpleVolumeShader',
  477: 'kSl60',
  478: 'kSnapshot',
  479: 'kStoryBoard',
  480: 'kSummaryObject',
  481: 'kSuper',
  482: 'kControl',
  483: 'kSurfaceLuminance',
  484: 'kSurfaceShader',
  485: 'kTextureList',
  486: 'kTextureEnv',
  487: 'kEnvBall',
  488: 'kEnvCube',
  489: 'kEnvChrome',
  490: 'kEnvSky',
  491: 'kEnvSphere',
  492: 'kTexture2d',
  493: 'kBulge',
  494: 'kChecker',
  495: 'kCloth',
  496: 'kFileTexture',
  497: 'kFractal',
  498: 'kGrid',
  499: 'kMountain',
  500: 'kRamp',
  501: 'kStencil',
  502: 'kWater',
  503: 'kTexture3d',
  504: 'kBrownian',
  505: 'kCloud',
  506: 'kCrater',
  507: 'kGranite',
  508: 'kLeather',
  509: 'kMarble',
  510: 'kRock',
  511: 'kSnow',
  512: 'kSolidFractal',
  513: 'kStucco',
  514: 'kTxSl',
  515: 'kWood',
  516: 'kTime',
  517: 'kTimeToUnitConversion',
  518: 'kRenderSetup',
  519: 'kRenderGlobals',
  520: 'kRenderGlobalsList',
  521: 'kRenderQuality',
  522: 'kResolution',
  523: 'kHardwareRenderGlobals',
  524: 'kArrayMapper',
  525: 'kUnitConversion',
  526: 'kUnitToTimeConversion',
  527: 'kUseBackground',
  528: 'kUnknown',
  529: 'kVectorProduct',
  530: 'kVolumeShader',
  531: 'kComponent',
  532: 'kCurveCVComponent',
  533: 'kCurveEPComponent',
  534: 'kCurveKnotComponent',
  535: 'kCurveParamComponent',
  536: 'kIsoparmComponent',
  537: 'kPivotComponent',
  538: 'kSurfaceCVComponent',
  539: 'kSurfaceEPComponent',
  540: 'kSurfaceKnotComponent',
  541: 'kEdgeComponent',
  542: 'kLatticeComponent',
  543: 'kSurfaceRangeComponent',
  544: 'kDecayRegionCapComponent',
  545: 'kDecayRegionComponent',
  546: 'kMeshComponent',
  547: 'kMeshEdgeComponent',
  548: 'kMeshPolygonComponent',
  549: 'kMeshFrEdgeComponent',
  550: 'kMeshVertComponent',
  551: 'kMeshFaceVertComponent',
  552: 'kOrientationComponent',
  553: 'kSubVertexComponent',
  554: 'kMultiSubVertexComponent',
  555: 'kSetGroupComponent',
  556: 'kDynParticleSetComponent',
  557: 'kSelectionItem',
  558: 'kDagSelectionItem',
  559: 'kNonDagSelectionItem',
  560: 'kItemList',
  561: 'kAttribute',
  562: 'kNumericAttribute',
  563: 'kDoubleAngleAttribute',
  564: 'kFloatAngleAttribute',
  565: 'kDoubleLinearAttribute',
  566: 'kFloatLinearAttribute',
  567: 'kTimeAttribute',
  568: 'kEnumAttribute',
  569: 'kUnitAttribute',
  570: 'kTypedAttribute',
  571: 'kCompoundAttribute',
  572: 'kGenericAttribute',
  573: 'kLightDataAttribute',
  574: 'kMatrixAttribute',
  575: 'kFloatMatrixAttribute',
  576: 'kMessageAttribute',
  577: 'kPlugin',
  578: 'kData',
  579: 'kComponentListData',
  580: 'kDoubleArrayData',
  581: 'kIntArrayData',
  582: 'kLatticeData',
  583: 'kMatrixData',
  584: 'kMeshData',
  585: 'kNurbsSurfaceData',
  586: 'kNurbsCurveData',
  587: 'kNumericData',
  588: 'kData2Double',
  589: 'kData2Float',
  590: 'kData2Int',
  591: 'kData2Short',
  592: 'kData3Double',
  593: 'kData3Float',
  594: 'kData3Int',
  595: 'kData3Short',
  596: 'kPluginData',
  597: 'kPointArrayData',
  598: 'kMatrixArrayData',
  599: 'kSphereData',
  600: 'kStringData',
  601: 'kStringArrayData',
  602: 'kVectorArrayData',
  603: 'kSelectionList',
  604: 'kTransformGeometry',
  605: 'kCommEdgePtManip',
  606: 'kCommEdgeOperManip',
  607: 'kCommEdgeSegmentManip',
  608: 'kCommCornerManip',
  609: 'kCommCornerOperManip',
  610: 'kPluginDeformerNode',
  611: 'kTorus',
  612: 'kPolyBoolOp',
  613: 'kSingleShadingSwitch',
  614: 'kDoubleShadingSwitch',
  615: 'kTripleShadingSwitch',
  616: 'kNurbsSquare',
  617: 'kAnisotropy',
  618: 'kNonLinear',
  619: 'kDeformFunc',
  620: 'kDeformBend',
  621: 'kDeformTwist',
  622: 'kDeformSquash',
  623: 'kDeformFlare',
  624: 'kDeformSine',
  625: 'kDeformWave',
  626: 'kDeformBendManip',
  627: 'kDeformTwistManip',
  628: 'kDeformSquashManip',
  629: 'kDeformFlareManip',
  630: 'kDeformSineManip',
  631: 'kDeformWaveManip',
  632: 'kSoftModManip',
  633: 'kDistanceManip',
  634: 'kScript',
  635: 'kCurveFromMeshEdge',
  636: 'kCurveCurveIntersect',
  637: 'kNurbsCircular3PtArc',
  638: 'kNurbsCircular2PtArc',
  639: 'kOffsetSurface',
  640: 'kRoundConstantRadius',
  641: 'kRoundRadiusManip',
  642: 'kRoundRadiusCrvManip',
  643: 'kRoundConstantRadiusManip',
  644: 'kThreePointArcManip',
  645: 'kTwoPointArcManip',
  646: 'kTextButtonManip',
  647: 'kOffsetSurfaceManip',
  648: 'kImageData',
  649: 'kImageLoad',
  650: 'kImageSave',
  651: 'kImageNetSrc',
  652: 'kImageNetDest',
  653: 'kImageRender',
  654: 'kImageAdd',
  655: 'kImageDiff',
  656: 'kImageMultiply',
  657: 'kImageOver',
  658: 'kImageUnder',
  659: 'kImageColorCorrect',
  660: 'kImageBlur',
  661: 'kImageFilter',
  662: 'kImageDepth',
  663: 'kImageDisplay',
  664: 'kImageView',
  665: 'kImageMotionBlur',
  666: 'kViewColorManager',
  667: 'kMatrixFloatData',
  668: 'kSkinShader',
  669: 'kComponentManip',
  670: 'kSelectionListData',
  671: 'kObjectFilter',
  672: 'kObjectMultiFilter',
  673: 'kObjectNameFilter',
  674: 'kObjectTypeFilter',
  675: 'kObjectAttrFilter',
  676: 'kObjectRenderFilter',
  677: 'kObjectScriptFilter',
  678: 'kSelectionListOperator',
  679: 'kSubdiv',
  680: 'kPolyToSubdiv',
  681: 'kSkinClusterFilter',
  682: 'kKeyingGroup',
  683: 'kCharacter',
  684: 'kCharacterOffset',
  685: 'kDagPose',
  686: 'kStitchAsNurbsShell',
  687: 'kExplodeNurbsShell',
  688: 'kNurbsBoolean',
  689: 'kStitchSrfManip',
  690: 'kForceUpdateManip',
  691: 'kPluginManipContainer',
  692: 'kPolySewEdge',
  693: 'kPolyMergeVert',
  694: 'kPolySmoothFacet',
  695: 'kSmoothCurve',
  696: 'kGlobalStitch',
  697: 'kSubdivCVComponent',
  698: 'kSubdivEdgeComponent',
  699: 'kSubdivFaceComponent',
  700: 'kUVManip2D',
  701: 'kTranslateUVManip2D',
  702: 'kRotateUVManip2D',
  703: 'kScaleUVManip2D',
  704: 'kPolyTweakUV',
  705: 'kMoveUVShellManip2D',
  706: 'kPluginShape',
  707: 'kGeometryData',
  708: 'kSingleIndexedComponent',
  709: 'kDoubleIndexedComponent',
  710: 'kTripleIndexedComponent',
  711: 'kExtendSurfaceDistanceManip',
  712: 'kSquareSrf',
  713: 'kSquareSrfManip',
  714: 'kSubdivToPoly',
  715: 'kDynBase',
  716: 'kDynEmitterManip',
  717: 'kDynFieldsManip',
  718: 'kDynBaseFieldManip',
  719: 'kDynAirManip',
  720: 'kDynNewtonManip',
  721: 'kDynTurbulenceManip',
  722: 'kDynSpreadManip',
  723: 'kDynAttenuationManip',
  724: 'kDynArrayAttrsData',
  725: 'kPluginFieldNode',
  726: 'kPluginEmitterNode',
  727: 'kPluginSpringNode',
  728: 'kDisplayLayer',
  729: 'kDisplayLayerManager',
  730: 'kPolyColorPerVertex',
  731: 'kCreateColorSet',
  732: 'kDeleteColorSet',
  733: 'kCopyColorSet',
  734: 'kBlendColorSet',
  735: 'kPolyColorMod',
  736: 'kPolyColorDel',
  737: 'kCharacterMappingData',
  738: 'kDynSweptGeometryData',
  739: 'kWrapFilter',
  740: 'kMeshVtxFaceComponent',
  741: 'kBinaryData',
  742: 'kAttribute2Double',
  743: 'kAttribute2Float',
  744: 'kAttribute2Short',
  745: 'kAttribute2Int',
  746: 'kAttribute3Double',
  747: 'kAttribute3Float',
  748: 'kAttribute3Short',
  749: 'kAttribute3Long',
  750: 'kReference',
  751: 'kBlindData',
  752: 'kBlindDataTemplate',
  753: 'kPolyBlindData',
  754: 'kPolyNormalPerVertex',
  755: 'kNurbsToSubdiv',
  756: 'kPluginIkSolver',
  757: 'kInstancer',
  758: 'kMoveVertexManip',
  759: 'kStroke',
  760: 'kBrush',
  761: 'kStrokeGlobals',
  762: 'kPluginGeometryData',
  763: 'kLightLink',
  764: 'kDynGlobals',
  765: 'kPolyReduce',
  766: 'kLodThresholds',
  767: 'kChooser',
  768: 'kLodGroup',
  769: 'kMultDoubleLinear',
  770: 'kFourByFourMatrix',
  771: 'kTowPointOnSurfaceManip',
  772: 'kSurfaceEdManip',
  773: 'kSurfaceFaceComponent',
  774: 'kClipScheduler',
  775: 'kClipLibrary',
  776: 'kSubSurface',
  777: 'kSmoothTangentSrf',
  778: 'kRenderPass',
  779: 'kRenderPassSet',
  780: 'kRenderLayer',
  781: 'kRenderLayerManager',
  782: 'kPassContributionMap',
  783: 'kPrecompExport',
  784: 'kRenderTarget',
  785: 'kRenderedImageSource',
  786: 'kImageSource',
  787: 'kPolyFlipEdge',
  788: 'kPolyExtrudeEdge',
  789: 'kAnimBlend',
  790: 'kAnimBlendInOut',
  791: 'kPolyAppendVertex',
  792: 'kUvChooser',
  793: 'kSubdivCompId',
  794: 'kVolumeAxis',
  795: 'kDeleteUVSet',
  796: 'kSubdHierBlind',
  797: 'kSubdBlindData',
  798: 'kCharacterMap',
  799: 'kLayeredTexture',
  800: 'kSubdivCollapse',
  801: 'kParticleSamplerInfo',
  802: 'kCopyUVSet',
  803: 'kCreateUVSet',
  804: 'kClip',
  805: 'kPolySplitVert',
  806: 'kSubdivData',
  807: 'kSubdivGeom',
  808: 'kUInt64ArrayData',
  809: 'kInt64ArrayData',
  810: 'kPolySplitEdge',
  811: 'kSubdivReverseFaces',
  812: 'kMeshMapComponent',
  813: 'kSectionManip',
  814: 'kXsectionSubdivEdit',
  815: 'kSubdivToNurbs',
  816: 'kEditCurve',
  817: 'kEditCurveManip',
  818: 'kCrossSectionManager',
  819: 'kCreateSectionManip',
  820: 'kCrossSectionEditManip',
  821: 'kDropOffFunction',
  822: 'kSubdBoolean',
  823: 'kSubdModifyEdge',
  824: 'kModifyEdgeCrvManip',
  825: 'kModifyEdgeManip',
  826: 'kScalePointManip',
  827: 'kTransformBoxManip',
  828: 'kSymmetryLocator',
  829: 'kSymmetryMapVector',
  830: 'kSymmetryMapCurve',
  831: 'kCurveFromSubdivEdge',
  832: 'kCreateBPManip',
  833: 'kModifyEdgeBaseManip',
  834: 'kSubdExtrudeFace',
  835: 'kSubdivSurfaceVarGroup',
  836: 'kSfRevolveManip',
  837: 'kCurveFromSubdivFace',
  838: 'kUnused1',
  839: 'kUnused2',
  840: 'kUnused3',
  841: 'kUnused4',
  842: 'kUnused5',
  843: 'kUnused6',
  844: 'kPolyTransfer',
  845: 'kPolyAverageVertex',
  846: 'kPolyAutoProj',
  847: 'kPolyLayoutUV',
  848: 'kPolyMapSewMove',
  849: 'kSubdModifier',
  850: 'kSubdMoveVertex',
  851: 'kSubdMoveEdge',
  852: 'kSubdMoveFace',
  853: 'kSubdDelFace',
  854: 'kSnapshotShape',
  855: 'kSubdivMapComponent',
  856: 'kJiggleDeformer',
  857: 'kGlobalCacheControls',
  858: 'kDiskCache',
  859: 'kSubdCloseBorder',
  860: 'kSubdMergeVert',
  861: 'kBoxData',
  862: 'kBox',
  863: 'kRenderBox',
  864: 'kSubdSplitFace',
  865: 'kVolumeFog',
  866: 'kSubdTweakUV',
  867: 'kSubdMapCut',
  868: 'kSubdLayoutUV',
  869: 'kSubdMapSewMove',
  870: 'kOcean',
  871: 'kVolumeNoise',
  872: 'kSubdAutoProj',
  873: 'kSubdSubdivideFace',
  874: 'kNoise',
  875: 'kAttribute4Double',
  876: 'kData4Double',
  877: 'kSubdPlanProj',
  878: 'kSubdTweak',
  879: 'kSubdProjectionManip',
  880: 'kSubdMappingManip',
  881: 'kHardwareReflectionMap',
  882: 'kPolyNormalizeUV',
  883: 'kPolyFlipUV',
  884: 'kHwShaderNode',
  885: 'kPluginHardwareShader',
  886: 'kPluginHwShaderNode',
  887: 'kSubdAddTopology',
  888: 'kSubdCleanTopology',
  889: 'kImplicitCone',
  890: 'kImplicitSphere',
  891: 'kRampShader',
  892: 'kVolumeLight',
  893: 'kOceanShader',
  894: 'kBevelPlus',
  895: 'kStyleCurve',
  896: 'kPolyCut',
  897: 'kPolyPoke',
  898: 'kPolyWedgeFace',
  899: 'kPolyCutManipContainer',
  900: 'kPolyCutManip',
  901: 'kPolyMirrorManipContainer',
  902: 'kPolyPokeManip',
  903: 'kFluidTexture3D',
  904: 'kFluidTexture2D',
  905: 'kPolyMergeUV',
  906: 'kPolyStraightenUVBorder',
  907: 'kAlignManip',
  908: 'kPluginTransformNode',
  909: 'kFluid',
  910: 'kFluidGeom',
  911: 'kFluidData',
  912: 'kSmear',
  913: 'kStringShadingSwitch',
  914: 'kStudioClearCoat',
  915: 'kFluidEmitter',
  916: 'kHeightField',
  917: 'kGeoConnector',
  918: 'kSnapshotPath',
  919: 'kPluginObjectSet',
  920: 'kQuadShadingSwitch',
  921: 'kPolyExtrudeVertex',
  922: 'kPairBlend',
  923: 'kTextManip',
  924: 'kViewManip',
  925: 'kXformManip',
  926: 'kMute',
  927: 'kConstraint',
  928: 'kTrimWithBoundaries',
  929: 'kCurveFromMeshCoM',
  930: 'kFollicle',
  931: 'kHairSystem',
  932: 'kRemapValue',
  933: 'kRemapColor',
  934: 'kRemapHsv',
  935: 'kHairConstraint',
  936: 'kTimeFunction',
  937: 'kMentalRayTexture',
  938: 'kObjectBinFilter',
  939: 'kPolySmoothProxy',
  940: 'kPfxGeometry',
  941: 'kPfxHair',
  942: 'kHairTubeShader',
  943: 'kPsdFileTexture',
  944: 'kKeyframeDelta',
  945: 'kKeyframeDeltaMove',
  946: 'kKeyframeDeltaScale',
  947: 'kKeyframeDeltaAddRemove',
  948: 'kKeyframeDeltaBlockAddRemove',
  949: 'kKeyframeDeltaInfType',
  950: 'kKeyframeDeltaTangent',
  951: 'kKeyframeDeltaWeighted',
  952: 'kKeyframeDeltaBreakdown',
  953: 'kPolyMirror',
  954: 'kPolyCreaseEdge',
  955: 'kPolyPinUV',
  956: 'kHikEffector',
  957: 'kHikIKEffector',
  958: 'kHikFKJoint',
  959: 'kHikSolver',
  960: 'kHikHandle',
  961: 'kProxyManager',
  962: 'kPolyAutoProjManip',
  963: 'kPolyPrism',
  964: 'kPolyPyramid',
  965: 'kPolySplitRing',
  966: 'kPfxToon',
  967: 'kToonLineAttributes',
  968: 'kPolyDuplicateEdge',
  969: 'kFacade',
  970: 'kMaterialFacade',
  971: 'kEnvFacade',
  972: 'kAISEnvFacade',
  973: 'kLineModifier',
  974: 'kPolyArrow',
  975: 'kPolyPrimitiveMisc',
  976: 'kPolyPlatonicSolid',
  977: 'kPolyPipe',
  978: 'kHikFloorContactMarker',
  979: 'kHikGroundPlane',
  980: 'kPolyComponentData',
  981: 'kPolyHelix',
  982: 'kCacheFile',
  983: 'kHistorySwitch',
  984: 'kClosestPointOnMesh',
  985: 'kTransferAttributes',
  986: 'kDynamicConstraint',
  987: 'kNComponent',
  988: 'kPolyBridgeEdge',
  989: 'kCacheableNode',
  990: 'kNucleus',
  991: 'kNBase',
  992: 'kCacheBase',
  993: 'kCacheBlend',
  994: 'kCacheTrack',
  995: 'kKeyframeRegionManip',
  996: 'kCurveNormalizerAngle',
  997: 'kCurveNormalizerLinear',
  998: 'kHyperLayoutDG',
  999: 'kPluginImagePlaneNode',
  1000: 'kNCloth',
  1001: 'kNParticle',
  1002: 'kNRigid',
  1003: 'kPluginParticleAttributeMapperNode',
  1004: 'kCameraSet',
  1005: 'kPluginCameraSet',
  1006: 'kContainer',
  1007: 'kFloatVectorArrayData',
  1008: 'kNObjectData',
  1009: 'kNObject',
  1010: 'kPluginConstraintNode',
  1011: 'kAsset',
  1012: 'kPolyEdgeToCurve',
  1013: 'kAnimLayer',
  1014: 'kBlendNodeBase',
  1015: 'kBlendNodeBoolean',
  1016: 'kBlendNodeDouble',
  1017: 'kBlendNodeDoubleAngle',
  1018: 'kBlendNodeDoubleLinear',
  1019: 'kBlendNodeEnum',
  1020: 'kBlendNodeFloat',
  1021: 'kBlendNodeFloatAngle',
  1022: 'kBlendNodeFloatLinear',
  1023: 'kBlendNodeInt16',
  1024: 'kBlendNodeInt32',
  1025: 'kBlendNodeAdditiveScale',
  1026: 'kBlendNodeAdditiveRotation',
  1027: 'kPluginManipulatorNode',
  1028: 'kNIdData',
  1029: 'kNId',
  1030: 'kFloatArrayData',
  1031: 'kMembrane',
  1032: 'kMergeVertsToolManip',
  1033: 'kUint64SingleIndexedComponent',
  1034: 'kPolyToolFeedbackManip',
  1035: 'kPolySelectEditFeedbackManip',
  1036: 'kWriteToFrameBuffer',
  1037: 'kWriteToColorBuffer',
  1038: 'kWriteToVectorBuffer',
  1039: 'kWriteToDepthBuffer',
  1040: 'kWriteToLabelBuffer',
  1041: 'kStereoCameraMaster',
  1042: 'kSequenceManager',
  1043: 'kSequencer',
  1044: 'kShot',
  1045: 'kBlendNodeTime',
  1046: 'kCreateBezierManip',
  1047: 'kBezierCurve',
  1048: 'kBezierCurveData',
  1049: 'kNurbsCurveToBezier',
  1050: 'kBezierCurveToNurbs',
  1051: 'kPolySpinEdge',
  1052: 'kPolyHoleFace',
  1053: 'kPointOnPolyConstraint',
  1054: 'kPolyConnectComponents',
  1055: 'kSkinBinding',
  1056: 'kVolumeBindManip',
  1057: 'kVertexWeightSet',
  1058: 'kNearestPointOnCurve',
  1059: 'kColorProfile',
  1060: 'kAdskMaterial',
  1061: 'kContainerBase',
  1062: 'kDagContainer',
  1063: 'kPolyUVRectangle',
  1064: 'kHardwareRenderingGlobals',
  1065: 'kPolyProjectCurve',
  1066: 'kRenderingList',
  1067: 'kPolyExtrudeManip',
  1068: 'kPolyExtrudeManipContainer',
  1069: 'kThreadedDevice',
  1070: 'kClientDevice',
  1071: 'kPluginClientDevice',
  1072: 'kPluginThreadedDevice',
  1073: 'kTimeWarp',
  1074: 'kAssembly',
  1075: 'kClipGhostShape',
  1076: 'kClipToGhostData',
  1077: 'kMandelbrot',
  1078: 'kMandelbrot3D',
  1079: 'kGreasePlane',
  1080: 'kGreasePlaneRenderShape',
  1081: 'kGreasePencilSequence',
  1082: 'kEditMetadata',
  1083: 'kCreaseSet',
  1084: 'kPolyEditEdgeFlow',
  1085: 'kFosterParent',
  1086: 'kSnapUVManip2D',
  1087: 'kToolContext',
  1088: 'kNLE',
  1089: 'kShrinkWrapFilter',
  1090: 'kEditsManager',
  1091: 'kPolyBevel2',
  1092: 'kPolyCBoolOp',
  1093: 'kGeomBind',
  1094: 'kColorMgtGlobals',
  1095: 'kPolyBevel3',
  1096: 'kTimeEditorClipBase',
  1097: 'kTimeEditorClipEvaluator',
  1098: 'kTimeEditorClip',
  1099: 'kTimeEditor',
  1100: 'kTimeEditorTracks',
  1101: 'kTimeEditorInterpolator',
  1102: 'kTimeEditorAnimSource',
  1103: 'kCaddyManipBase',
  1104: 'kPolyCaddyManip',
  1105: 'kPolyModifierManipContainer',
  1106: 'kPolyRemesh',
  1107: 'kPolyContourProj',
  1108: 'kContourProjectionManip',
  1109: 'kNodeGraphEditorInfo',
  1110: 'kNodeGraphEditorBookmarks',
  1111: 'kNodeGraphEditorBookmarkInfo',
  1112: 'kPluginSkinCluster',
  1113: 'kPluginGeometryFilter',
  1114: 'kPluginBlendShape',
  1115: 'kPolyPassThru',
  1116: 'kTrackInfoManager',
  1117: 'kPolyClean',
  1118: 'kShapeEditorManager',
  1119: 'kOceanDeformer',
  1120: 'kPoseInterpolatorManager',
  1121: 'kControllerTag',
  1122: 'kCustomEvaluatorClusterNode',
  1123: 'kPolyCircularize',
  1124: 'kArubaTesselate',
  1125: 'kReorderUVSet',
  1126: 'kLast'},
 {u'AISEnvFacade': 'kAISEnvFacade',
  u'AlembicNode': 'kPluginDependNode',
  u'BifMeshImportNode': 'kPluginDependNode',
  u'BossBlender': 'kPluginDependNode',
  u'BossEXRInfluence': 'kPluginDependNode',
  u'BossGeoProperties': 'kPluginDependNode',
  u'BossSpectralWave': 'kPluginDependNode',
  u'BossWaveSolver': 'kPluginDependNode',
  u'ComputeGlobal': 'kPluginDependNode',
  u'ComputeLocal': 'kPluginDependNode',
  u'CustomRigDefaultMappingNode': 'kPluginDependNode',
  u'CustomRigRetargeterNode': 'kPluginDependNode',
  u'FurAttractors': 'kPluginDependNode',
  u'FurCurveAttractors': 'kPluginDependNode',
  u'FurDescription': 'kPluginDependNode',
  u'FurFeedback': 'kPluginLocatorNode',
  u'FurGlobals': 'kPluginDependNode',
  u'GLSLShader': 'kPluginHardwareShader',
  u'HIKCharacterNode': 'kPluginDependNode',
  u'HIKCharacterStateClient': 'kPluginClientDevice',
  u'HIKControlSetNode': 'kPluginDependNode',
  u'HIKEffector2State': 'kPluginDependNode',
  u'HIKEffectorFromCharacter': 'kPluginDependNode',
  u'HIKFK2State': 'kPluginDependNode',
  u'HIKPinning2State': 'kPluginDependNode',
  u'HIKProperty2State': 'kPluginDependNode',
  u'HIKRetargeterNode': 'kPluginDependNode',
  u'HIKSK2State': 'kPluginDependNode',
  u'HIKSkeletonGeneratorNode': 'kPluginDependNode',
  u'HIKSolverNode': 'kPluginDependNode',
  u'HIKState2Effector': 'kPluginDependNode',
  u'HIKState2FK': 'kPluginDependNode',
  u'HIKState2GlobalSK': 'kPluginDependNode',
  u'HIKState2SK': 'kPluginDependNode',
  u'MASH_Audio': 'kPluginDependNode',
  u'MASH_BaseNode': 'kPluginDependNode',
  u'MASH_Blend': 'kPluginDependNode',
  u'MASH_BlendDeformer': 'kPluginDeformerNode',
  u'MASH_Breakout': 'kPluginDependNode',
  u'MASH_BulletSolver': 'kPluginLocatorNode',
  u'MASH_ChannelRandom': 'kPluginDependNode',
  u'MASH_Color': 'kPluginDependNode',
  u'MASH_Constraint': 'kPluginDependNode',
  u'MASH_Curve': 'kPluginDependNode',
  u'MASH_Deformer': 'kPluginDeformerNode',
  u'MASH_Delay': 'kPluginDependNode',
  u'MASH_Distribute': 'kPluginDependNode',
  u'MASH_Dynamics': 'kPluginDependNode',
  u'MASH_DynamicsInitialState': 'kPluginDependNode',
  u'MASH_Explode': 'kPluginDependNode',
  u'MASH_Falloff': 'kPluginLocatorNode',
  u'MASH_Flight': 'kPluginLocatorNode',
  u'MASH_Font': 'kPluginLocatorNode',
  u'MASH_Id': 'kPluginDependNode',
  u'MASH_Influence': 'kPluginDependNode',
  u'MASH_Inherit': 'kPluginDependNode',
  u'MASH_InitialState': 'kPluginDependNode',
  u'MASH_Jiggle': 'kPluginDeformerNode',
  u'MASH_Legacy': 'kPluginDependNode',
  u'MASH_Maths': 'kPluginDependNode',
  u'MASH_MultiCurve': 'kPluginDependNode',
  u'MASH_Mute': 'kPluginDependNode',
  u'MASH_Noise': 'kPluginDependNode',
  u'MASH_Offset': 'kPluginDependNode',
  u'MASH_Orient': 'kPluginDependNode',
  u'MASH_PfxConnect': 'kPluginDependNode',
  u'MASH_Placer': 'kPluginDependNode',
  u'MASH_PointToCurve': 'kPluginDependNode',
  u'MASH_Points': 'kPluginLocatorNode',
  u'MASH_Python': 'kPluginDependNode',
  u'MASH_Random': 'kPluginDependNode',
  u'MASH_Replicator': 'kPluginDependNode',
  u'MASH_Repro': 'kPluginDependNode',
  u'MASH_ShellDeformer': 'kPluginDeformerNode',
  u'MASH_Signal': 'kPluginDependNode',
  u'MASH_Spring': 'kPluginDependNode',
  u'MASH_Strength': 'kPluginDependNode',
  u'MASH_Symmetry': 'kPluginDependNode',
  u'MASH_Time': 'kPluginDependNode',
  u'MASH_Trails': 'kPluginDependNode',
  u'MASH_Transform': 'kPluginDependNode',
  u'MASH_Trig': 'kPluginDependNode',
  u'MASH_Visibility': 'kPluginDependNode',
  u'MASH_Waiter': 'kPluginObjectSet',
  u'MASH_World': 'kPluginDependNode',
  u'ShaderfxGameHair': 'kPluginHardwareShader',
  u'ShaderfxShader': 'kPluginHardwareShader',
  u'SphereLocator': 'kPluginLocatorNode',
  u'StingrayPBS': 'kPluginHardwareShader',
  u'THarrayMapper': 'kPluginParticleAttributeMapperNode',
  'THassembly': 'kAssembly',
  u'THblendShape': 'kPluginBlendShape',
  u'THcameraSet': 'kPluginCameraSet',
  u'THclientDevice': 'kPluginClientDevice',
  u'THconstraint': 'kPluginConstraintNode',
  u'THcustomTransform': 'kPluginTransformNode',
  u'THdeformer': 'kPluginDeformerNode',
  u'THdependNode': 'kPluginDependNode',
  u'THdynEmitter': 'kPluginEmitterNode',
  u'THdynField': 'kPluginFieldNode',
  u'THdynSpring': 'kPluginSpringNode',
  u'THfluidEmitter': 'kPluginEmitterNode',
  u'THgeometryFilter': 'kPluginGeometryFilter',
  u'THhardwareShader': 'kPluginHardwareShader',
  u'THhwShader': 'kPluginHwShaderNode',
  u'THikSolverNode': 'kPluginIkSolver',
  u'THimagePlane': 'kPluginImagePlaneNode',
  u'THlocatorShape': 'kPluginLocatorNode',
  'THmanip': 'kPluginManipulatorNode',
  u'THmanipContainer': 'kPluginManipContainer',
  u'THmotionPath': 'kPluginMotionPathNode',
  u'THobjectSet': 'kPluginObjectSet',
  u'THskinCluster': 'kPluginSkinCluster',
  u'THsurfaceShape': 'kPluginShape',
  u'TadskAssetInstanceNode_TdependNode': 'kDependencyNode',
  u'TadskAssetInstanceNode_TdnTx2D': u'kTexture2d',
  u'TadskAssetInstanceNode_TlightShape': u'kLight',
  u'aboutToSetValueTestNode': 'kDependencyNode',
  u'absOverride': 'kPluginDependNode',
  u'absUniqueOverride': 'kPluginDependNode',
  u'abstractBaseCreate': 'kCreate',
  u'abstractBaseNurbsConversion': 'kCreate',
  u'addDoubleLinear': 'kAddDoubleLinear',
  u'addMatrix': 'kMatrixAdd',
  u'adskMaterial': 'kAdskMaterial',
  u'adskPrepareRenderGlobals': 'kPluginDependNode',
  u'aiAOV': 'kPluginDependNode',
  u'aiAOVDriver': 'kPluginDependNode',
  u'aiAOVFilter': 'kPluginDependNode',
  u'aiAbs': 'kPluginDependNode',
  u'aiAdd': 'kPluginDependNode',
  u'aiAmbientOcclusion': 'kPluginDependNode',
  u'aiAreaLight': 'kPluginLocatorNode',
  u'aiAtan': 'kPluginDependNode',
  u'aiAtmosphereVolume': 'kPluginDependNode',
  u'aiBarndoor': 'kPluginDependNode',
  u'aiBlackbody': 'kPluginDependNode',
  u'aiBump2d': 'kPluginDependNode',
  u'aiBump3d': 'kPluginDependNode',
  u'aiCache': 'kPluginDependNode',
  u'aiClamp': 'kPluginDependNode',
  u'aiColorConvert': 'kPluginDependNode',
  u'aiColorCorrect': 'kPluginDependNode',
  u'aiColorJitter': 'kPluginDependNode',
  u'aiColorToFloat': 'kPluginDependNode',
  u'aiCompare': 'kPluginDependNode',
  u'aiComplement': 'kPluginDependNode',
  u'aiComplexIor': 'kPluginDependNode',
  u'aiComposite': 'kPluginDependNode',
  u'aiCross': 'kPluginDependNode',
  u'aiCurvature': 'kPluginDependNode',
  u'aiCurveCollector': 'kPluginLocatorNode',
  u'aiDivide': 'kPluginDependNode',
  u'aiDot': 'kPluginDependNode',
  u'aiExp': 'kPluginDependNode',
  u'aiFacingRatio': 'kPluginDependNode',
  u'aiFlakes': 'kPluginDependNode',
  u'aiFlat': 'kPluginDependNode',
  u'aiFloatToInt': 'kPluginDependNode',
  u'aiFog': 'kPluginDependNode',
  u'aiFraction': 'kPluginDependNode',
  u'aiGobo': 'kPluginDependNode',
  u'aiHair': 'kPluginDependNode',
  u'aiImage': 'kPluginDependNode',
  u'aiIsFinite': 'kPluginDependNode',
  u'aiLength': 'kPluginDependNode',
  u'aiLightBlocker': 'kPluginLocatorNode',
  u'aiLightDecay': 'kPluginDependNode',
  u'aiLightPortal': 'kPluginLocatorNode',
  u'aiLog': 'kPluginDependNode',
  u'aiMax': 'kPluginDependNode',
  u'aiMeshLight': 'kPluginLocatorNode',
  u'aiMin': 'kPluginDependNode',
  u'aiMixShader': 'kPluginDependNode',
  u'aiModulo': 'kPluginDependNode',
  u'aiMotionVector': 'kPluginDependNode',
  u'aiMultiply': 'kPluginDependNode',
  u'aiNegate': 'kPluginDependNode',
  u'aiNoise': 'kPluginDependNode',
  u'aiNormalMap': 'kPluginDependNode',
  u'aiNormalize': 'kPluginDependNode',
  u'aiOptions': 'kPluginDependNode',
  u'aiPhotometricLight': 'kPluginLocatorNode',
  u'aiPhysicalSky': 'kPluginDependNode',
  u'aiPow': 'kPluginDependNode',
  u'aiRandom': 'kPluginDependNode',
  u'aiRange': 'kPluginDependNode',
  u'aiRaySwitch': 'kPluginDependNode',
  u'aiReciprocal': 'kPluginDependNode',
  u'aiShadowMatte': 'kPluginDependNode',
  u'aiShuffle': 'kPluginDependNode',
  u'aiSign': 'kPluginDependNode',
  u'aiSkin': 'kPluginDependNode',
  u'aiSky': 'kPluginLocatorNode',
  u'aiSkyDomeLight': 'kPluginLocatorNode',
  u'aiSpaceTransform': 'kPluginDependNode',
  u'aiSqrt': 'kPluginDependNode',
  u'aiStandIn': 'kPluginShape',
  u'aiStandard': 'kPluginDependNode',
  u'aiStandardHair': 'kPluginDependNode',
  u'aiStandardSurface': 'kPluginDependNode',
  u'aiStandardVolume': 'kPluginDependNode',
  u'aiSubstract': 'kPluginDependNode',
  u'aiSwitch': 'kPluginDependNode',
  u'aiThinFilm': 'kPluginDependNode',
  u'aiTrigo': 'kPluginDependNode',
  u'aiTriplanar': 'kPluginDependNode',
  u'aiTwoSided': 'kPluginDependNode',
  u'aiUserDataBool': 'kPluginDependNode',
  u'aiUserDataColor': 'kPluginDependNode',
  u'aiUserDataFloat': 'kPluginDependNode',
  u'aiUserDataInt': 'kPluginDependNode',
  u'aiUserDataString': 'kPluginDependNode',
  u'aiUserDataVec2': 'kPluginDependNode',
  u'aiUserDataVector': 'kPluginDependNode',
  u'aiUtility': 'kPluginDependNode',
  u'aiUvTransform': 'kPluginDependNode',
  u'aiVectorMap': 'kPluginDependNode',
  u'aiVolume': 'kPluginShape',
  u'aiVolumeCollector': 'kPluginDependNode',
  u'aiVolumeSampleFloat': 'kPluginDependNode',
  u'aiVolumeSampleRgb': 'kPluginDependNode',
  u'aiWireframe': 'kPluginDependNode',
  u'aiWriteColor': 'kPluginDependNode',
  u'aiWriteFloat': 'kPluginDependNode',
  u'aimConstraint': 'kAimConstraint',
  u'airField': 'kAir',
  u'alignCurve': 'kAlignCurve',
  u'alignSurface': 'kAlignSurface',
  u'ambientLight': 'kAmbientLight',
  u'angleBetween': 'kAngleBetween',
  u'angleDimension': 'kAngle',
  u'animBlend': 'kAnimBlend',
  u'animBlendInOut': 'kAnimBlendInOut',
  u'animBlendNodeAdditive': 'kBlendNodeDouble',
  u'animBlendNodeAdditiveDA': 'kBlendNodeDoubleAngle',
  u'animBlendNodeAdditiveDL': 'kBlendNodeDoubleLinear',
  u'animBlendNodeAdditiveF': 'kBlendNodeFloat',
  u'animBlendNodeAdditiveFA': 'kBlendNodeFloatAngle',
  u'animBlendNodeAdditiveFL': 'kBlendNodeFloatLinear',
  u'animBlendNodeAdditiveI16': 'kBlendNodeInt16',
  u'animBlendNodeAdditiveI32': 'kBlendNodeInt32',
  u'animBlendNodeAdditiveRotation': 'kBlendNodeAdditiveRotation',
  u'animBlendNodeAdditiveScale': 'kBlendNodeAdditiveScale',
  u'animBlendNodeBase': 'kDependencyNode',
  u'animBlendNodeBoolean': 'kBlendNodeBoolean',
  u'animBlendNodeEnum': 'kBlendNodeEnum',
  u'animBlendNodeTime': 'kBlendNodeTime',
  u'animClip': 'kClip',
  u'animCurve': u'kAnimCurve',
  u'animCurveTA': 'kAnimCurveTimeToAngular',
  u'animCurveTL': 'kAnimCurveTimeToDistance',
  u'animCurveTT': 'kAnimCurveTimeToTime',
  u'animCurveTU': 'kAnimCurveTimeToUnitless',
  u'animCurveUA': 'kAnimCurveUnitlessToAngular',
  u'animCurveUL': 'kAnimCurveUnitlessToDistance',
  u'animCurveUT': 'kAnimCurveUnitlessToTime',
  u'animCurveUU': 'kAnimCurveUnitlessToUnitless',
  u'animLayer': 'kAnimLayer',
  u'anisotropic': 'kAnisotropy',
  u'annotationShape': 'kAnnotation',
  u'aovChildCollection': 'kPluginDependNode',
  u'aovCollection': 'kPluginDependNode',
  u'apfEntityNode': 'kPluginTransformNode',
  u'apfFileNode': 'kPluginDependNode',
  u'applyAbs2FloatsOverride': 'kPluginDependNode',
  u'applyAbs3FloatsOverride': 'kPluginDependNode',
  u'applyAbsBoolOverride': 'kPluginDependNode',
  u'applyAbsEnumOverride': 'kPluginDependNode',
  u'applyAbsFloatOverride': 'kPluginDependNode',
  u'applyAbsIntOverride': 'kPluginDependNode',
  u'applyAbsOverride': 'kPluginDependNode',
  u'applyAbsStringOverride': 'kPluginDependNode',
  u'applyConnectionOverride': 'kPluginDependNode',
  u'applyOverride': 'kPluginDependNode',
  u'applyRel2FloatsOverride': 'kPluginDependNode',
  u'applyRel3FloatsOverride': 'kPluginDependNode',
  u'applyRelFloatOverride': 'kPluginDependNode',
  u'applyRelIntOverride': 'kPluginDependNode',
  u'applyRelOverride': 'kPluginDependNode',
  u'arcLengthDimension': 'kArcLength',
  u'areaLight': 'kAreaLight',
  u'arnoldAOVChildSelector': 'kPluginDependNode',
  u'arrayMapper': 'kArrayMapper',
  u'arubaTessellate': 'kArubaTesselate',
  u'assembly': u'kAssembly',
  u'assemblyDefinition': 'kAssembly',
  u'assemblyReference': 'kAssembly',
  u'attachCurve': 'kAttachCurve',
  u'attachSurface': 'kAttachSurface',
  u'attrHierarchyTest': 'kDependencyNode',
  u'audio': 'kAudio',
  u'avgCurves': 'kAvgCurves',
  u'avgNurbsSurfacePoints': 'kAvgNurbsSurfacePoints',
  u'avgSurfacePoints': 'kAvgSurfacePoints',
  u'bakeSet': 'kSet',
  u'baseGeometryVarGroup': 'kTransform',
  u'baseLattice': 'kBaseLattice',
  u'baseShadingSwitch': 'kDependencyNode',
  u'basicSelector': 'kPluginDependNode',
  u'bevel': 'kBevel',
  u'bevelPlus': 'kBevelPlus',
  u'bezierCurve': 'kNurbsCurve',
  u'bezierCurveToNurbs': 'kBezierCurveToNurbs',
  u'bifShape': 'kPluginShape',
  u'bifrostAeroMaterial': 'kPluginDependNode',
  u'bifrostAttrNotifier': 'kPluginDependNode',
  u'bifrostBoard': 'kPluginDependNode',
  u'bifrostContainer': 'kPluginLocatorNode',
  u'bifrostFoamMaterial': 'kPluginDependNode',
  u'bifrostLiquidMaterial': 'kPluginDependNode',
  u'bifrostShape': 'kPluginShape',
  u'birailSrf': u'kBirailSrf',
  u'blend': u'kBlend',
  u'blendColorSets': 'kBlendColorSet',
  u'blendColors': 'kBlendColors',
  u'blendDevice': 'kBlendDevice',
  u'blendShape': 'kBlendShape',
  u'blendTwoAttr': 'kBlendTwoAttr',
  u'blendWeighted': 'kBlendWeighted',
  u'blindDataTemplate': 'kBlindDataTemplate',
  u'blinn': 'kBlinn',
  u'boneLattice': 'kBulgeLattice',
  u'boolean': 'kNurbsBoolean',
  u'boundary': 'kBoundary',
  u'boundaryBase': 'kCreate',
  u'brownian': 'kBrownian',
  u'brush': 'kBrush',
  u'bulge': 'kBulge',
  u'bulletInitialState': 'kPluginShape',
  u'bulletRigidBodyConstraintShape': 'kPluginLocatorNode',
  u'bulletRigidBodyShape': 'kPluginLocatorNode',
  u'bulletRigidCollection': 'kPluginShape',
  u'bulletRigidSet': 'kPluginObjectSet',
  u'bulletSoftBodyShape': 'kPluginLocatorNode',
  u'bulletSoftConstraintShape': 'kPluginLocatorNode',
  u'bulletSolverShape': 'kPluginShape',
  u'bump2d': 'kBump',
  u'bump3d': 'kBump3d',
  u'cMuscleCreator': 'kPluginDependNode',
  u'cMuscleDebug': 'kPluginLocatorNode',
  u'cMuscleDirection': 'kPluginLocatorNode',
  u'cMuscleDisplace': 'kPluginLocatorNode',
  u'cMuscleDisplay': 'kPluginLocatorNode',
  u'cMuscleFalloff': 'kPluginLocatorNode',
  u'cMuscleKeepOut': 'kPluginLocatorNode',
  u'cMuscleMultiCollide': 'kPluginDeformerNode',
  u'cMuscleObject': 'kPluginLocatorNode',
  u'cMuscleRelative': 'kPluginDeformerNode',
  u'cMuscleShader': 'kPluginDependNode',
  u'cMuscleSmartCollide': 'kPluginLocatorNode',
  u'cMuscleSmartConstraint': 'kPluginDependNode',
  u'cMuscleSpline': 'kPluginLocatorNode',
  u'cMuscleSplineDeformer': 'kPluginDeformerNode',
  u'cMuscleStretch': 'kPluginDeformerNode',
  u'cMuscleSurfAttach': 'kPluginLocatorNode',
  u'cMuscleSystem': 'kPluginDeformerNode',
  u'cacheBase': u'kCacheBase',
  u'cacheBlend': 'kCacheTrack',
  u'cacheFile': 'kCacheFile',
  u'camera': 'kCamera',
  u'cameraSet': 'kCameraSet',
  u'cameraView': 'kCameraView',
  u'cgfxShader': 'kPluginHwShaderNode',
  u'cgfxVector': 'kPluginDependNode',
  u'channels': 'kPluginDependNode',
  u'character': 'kCharacter',
  u'characterMap': 'kCharacterMap',
  u'characterOffset': 'kCharacterOffset',
  u'checker': 'kChecker',
  u'childNode': 'kPluginDependNode',
  u'choice': 'kChoice',
  u'chooser': 'kChooser',
  u'clamp': 'kClampColor',
  u'clearCoat': 'kPluginDependNode',
  u'clientDevice': u'kClientDevice',
  u'clipGhostShape': 'kClipGhostShape',
  u'clipLibrary': 'kClipLibrary',
  u'clipScheduler': 'kClipScheduler',
  u'clipToGhostData': 'kClipToGhostData',
  u'closeCurve': 'kCloseCurve',
  u'closeSurface': 'kCloseSurface',
  u'closestPointOnMesh': 'kClosestPointOnMesh',
  u'closestPointOnSurface': 'kClosestPointOnSurface',
  u'cloth': 'kCloth',
  u'cloud': 'kCloud',
  u'cluster': 'kClusterFilter',
  u'clusterFlexorShape': 'kClusterFlexor',
  u'clusterHandle': 'kCluster',
  u'collection': 'kPluginDependNode',
  u'collisionModel': 'kCollision',
  u'colorComposite': 'kPluginDependNode',
  u'colorCondition': 'kPluginDependNode',
  u'colorConstant': 'kPluginDependNode',
  u'colorCorrect': 'kPluginDependNode',
  u'colorLogic': 'kPluginDependNode',
  u'colorManagementGlobals': 'kColorMgtGlobals',
  u'colorMask': 'kPluginDependNode',
  u'colorMath': 'kPluginDependNode',
  u'colorProfile': 'kColorProfile',
  u'combinationShape': 'kCombinationShape',
  u'compactPlugArrayTest': 'kDependencyNode',
  u'composeMatrix': 'kPluginDependNode',
  u'condition': 'kCondition',
  u'coneAngleToHotspotConverter': 'kPluginDependNode',
  u'connectionOverride': 'kPluginDependNode',
  u'connectionUniqueOverride': 'kPluginDependNode',
  u'constraint': u'kConstraint',
  u'container': 'kContainer',
  u'containerBase': 'kContainerBase',
  u'contrast': 'kContrast',
  u'controlPoint': u'kShape',
  u'controller': 'kControllerTag',
  u'copyColorSet': 'kCopyColorSet',
  u'copyUVSet': 'kCopyUVSet',
  u'crater': 'kCrater',
  u'creaseSet': 'kCreaseSet',
  u'createColorSet': 'kCreateColorSet',
  u'createPtexUV': 'kPluginDependNode',
  u'createUVSet': 'kCreateUVSet',
  u'curveFromMesh': 'kDependencyNode',
  u'curveFromMeshCoM': 'kCurveFromMeshCoM',
  u'curveFromMeshEdge': 'kCurveFromMeshEdge',
  u'curveFromSubdiv': 'kCreate',
  u'curveFromSubdivEdge': 'kCurveFromSubdivEdge',
  u'curveFromSubdivFace': 'kCurveFromSubdivFace',
  u'curveFromSurface': u'kCurveFromSurface',
  u'curveFromSurfaceBnd': 'kCurveFromSurfaceBnd',
  u'curveFromSurfaceCoS': 'kCurveFromSurfaceCoS',
  u'curveFromSurfaceIso': 'kCurveFromSurfaceIso',
  u'curveInfo': 'kCurveInfo',
  u'curveIntersect': 'kCurveCurveIntersect',
  u'curveNormalizer': 'kDependencyNode',
  u'curveNormalizerAngle': 'kCurveNormalizerAngle',
  u'curveNormalizerLinear': 'kCurveNormalizerLinear',
  u'curveRange': 'kCreate',
  u'curveShape': 'kCurve',
  u'curveVarGroup': 'kCurveVarGroup',
  u'curveWarp': 'kPluginDeformerNode',
  u'dagContainer': 'kDagContainer',
  u'dagNode': u'kDagNode',
  u'dagPose': 'kDagPose',
  u'dataBlockTest': 'kDependencyNode',
  u'decomposeMatrix': 'kPluginDependNode',
  u'defaultLightList': 'kDefaultLightList',
  u'defaultRenderUtilityList': 'kRenderUtilityList',
  u'defaultRenderingList': 'kRenderingList',
  u'defaultShaderList': 'kShaderList',
  u'defaultTextureList': 'kTextureList',
  u'deformBend': 'kDeformBend',
  u'deformFlare': 'kDeformFlare',
  u'deformFunc': u'kDeformFunc',
  u'deformSine': 'kDeformSine',
  u'deformSquash': 'kDeformSquash',
  u'deformTwist': 'kDeformTwist',
  u'deformWave': 'kDeformWave',
  u'deformableShape': u'kShape',
  u'deleteColorSet': 'kDeleteColorSet',
  u'deleteComponent': 'kDeleteComponent',
  u'deleteUVSet': 'kDeleteUVSet',
  u'deltaMush': 'kDeltaMush',
  'dependNode': 'kDependencyNode',
  u'detachCurve': 'kDetachCurve',
  u'detachSurface': 'kDetachSurface',
  u'dimensionShape': 'kDimension',
  u'directedDisc': 'kDirectedDisc',
  u'directionalLight': 'kDirectionalLight',
  u'diskCache': 'kDiskCache',
  u'displacementShader': 'kDisplacementShader',
  u'displayLayer': 'kDisplayLayer',
  u'displayLayerManager': 'kDisplayLayerManager',
  u'displayPoints': 'kPluginLocatorNode',
  u'distanceBetween': 'kDistanceBetween',
  u'distanceDimShape': 'kDistance',
  u'dof': 'kDOF',
  u'doubleShadingSwitch': 'kDoubleShadingSwitch',
  u'dpBirailSrf': 'kDPbirailSrf',
  u'dragField': 'kDrag',
  u'dropoffLocator': 'kDropoffLocator',
  u'dx11Shader': 'kPluginHardwareShader',
  u'dynBase': u'kDynBase',
  u'dynController': 'kDynamicsController',
  u'dynGlobals': 'kDynGlobals',
  u'dynHolder': 'kDummy',
  u'dynamicConstraint': 'kDynamicConstraint',
  u'editMetadata': 'kEditMetadata',
  u'editsManager': 'kEditsManager',
  u'entity': 'kContainerBase',
  u'envBall': 'kEnvBall',
  u'envChrome': 'kEnvChrome',
  u'envCube': 'kEnvCube',
  u'envFacade': 'kEnvFacade',
  u'envFog': 'kEnvFogMaterial',
  u'envSky': 'kEnvSky',
  u'envSphere': 'kEnvSphere',
  u'environmentFog': 'kEnvFogShape',
  u'eulerToQuat': 'kPluginDependNode',
  u'explodeNurbsShell': 'kExplodeNurbsShell',
  u'expression': 'kExpression',
  u'extendCurve': 'kExtendCurve',
  u'extendSurface': 'kExtendSurface',
  u'extrude': 'kExtrude',
  u'facade': 'kFacade',
  u'ffBlendSrf': 'kFFblendSrf',
  u'ffBlendSrfObsolete': 'kFFblendSrf',
  u'ffFilletSrf': 'kFFfilletSrf',
  u'ffd': 'kFFD',
  u'field': u'kField',
  u'file': 'kFileTexture',
  u'filletCurve': 'kFilletCurve',
  u'fitBspline': 'kFitBspline',
  u'flexorShape': 'kFlexor',
  u'floatComposite': 'kPluginDependNode',
  u'floatCondition': 'kPluginDependNode',
  u'floatConstant': 'kPluginDependNode',
  u'floatCorrect': 'kPluginDependNode',
  u'floatLogic': 'kPluginDependNode',
  u'floatMask': 'kPluginDependNode',
  u'floatMath': 'kPluginDependNode',
  u'flow': 'kFlow',
  u'fltLightPointShape': 'kPluginShape',
  u'fltSwitchNode': 'kPluginDependNode',
  u'fluidEmitter': 'kFluidEmitter',
  u'fluidShape': 'kFluid',
  u'fluidTexture2D': 'kFluidTexture2D',
  u'fluidTexture3D': 'kFluidTexture3D',
  u'follicle': 'kFollicle',
  u'fosterParent': 'kFosterParent',
  u'fourByFourMatrix': 'kFourByFourMatrix',
  u'fractal': 'kFractal',
  u'frameCache': 'kTime',
  u'furPointOnMeshInfo': 'kPluginDependNode',
  u'furPointOnSubd': 'kPluginDependNode',
  u'gameFbxExporter': 'kPluginDependNode',
  u'gammaCorrect': 'kGammaCorrect',
  u'geoConnectable': 'kGeoConnectable',
  u'geoConnector': 'kGeoConnector',
  u'geomBind': 'kGeomBind',
  u'geometryConstraint': 'kGeometryConstraint',
  u'geometryFilter': 'kGeometryFilt',
  u'geometryShape': u'kShape',
  u'geometryVarGroup': 'kAnyGeometryVarGroup',
  u'globalCacheControl': 'kGlobalCacheControls',
  u'globalStitch': 'kGlobalStitch',
  u'gpuCache': 'kPluginShape',
  u'granite': 'kGranite',
  u'gravityField': 'kGravity',
  u'greasePencilSequence': 'kGreasePencilSequence',
  u'greasePlane': 'kGreasePlane',
  u'greasePlaneRenderShape': 'kGreasePlaneRenderShape',
  u'grid': 'kGrid',
  u'groundPlane': u'kGroundPlane',
  u'groupId': 'kGroupId',
  u'groupParts': 'kGroupParts',
  u'guide': 'kGuide',
  u'hairConstraint': 'kHairConstraint',
  u'hairPhysicalShader': 'kPluginDependNode',
  u'hairSystem': 'kHairSystem',
  u'hairTubeShader': 'kHairTubeShader',
  u'hardenPoint': 'kHardenPointCurve',
  u'hardwareRenderGlobals': 'kHardwareRenderGlobals',
  u'hardwareRenderingGlobals': 'kHardwareRenderingGlobals',
  u'heightField': 'kHeightField',
  u'hierarchyTestNode1': 'kDependencyNode',
  u'hierarchyTestNode2': 'kDependencyNode',
  u'hierarchyTestNode3': 'kDependencyNode',
  u'hikEffector': 'kHikEffector',
  u'hikFKJoint': 'kHikFKJoint',
  u'hikFloorContactMarker': 'kHikFloorContactMarker',
  u'hikGroundPlane': 'kHikGroundPlane',
  u'hikHandle': 'kHikHandle',
  u'hikIKEffector': 'kHikIKEffector',
  u'hikSolver': 'kHikSolver',
  u'historySwitch': 'kHistorySwitch',
  u'holdMatrix': 'kMatrixHold',
  u'hsvToRgb': 'kHsvToRgb',
  u'hwReflectionMap': 'kHardwareReflectionMap',
  u'hwRenderGlobals': 'kHardwareRenderGlobals',
  u'hwShader': 'kHwShaderNode',
  u'hyperGraphInfo': 'kHyperGraphInfo',
  u'hyperLayout': 'kHyperLayout',
  u'hyperView': 'kHyperView',
  u'igmDescription': 'kPluginLocatorNode',
  u'ik2Bsolver': 'kPluginIkSolver',
  u'ikEffector': 'kIkEffector',
  u'ikHandle': 'kIkHandle',
  u'ikMCsolver': 'kMCsolver',
  u'ikPASolver': 'kPASolver',
  u'ikRPsolver': 'kRPsolver',
  u'ikSCsolver': 'kSCsolver',
  u'ikSolver': u'kIkSolver',
  u'ikSplineSolver': 'kSplineSolver',
  u'ikSpringSolver': 'kPluginIkSolver',
  u'ikSystem': 'kIkSystem',
  u'ilrAshikhminShader': 'kPluginDependNode',
  u'ilrBakeLayer': 'kPluginObjectSet',
  u'ilrBakeLayerManager': 'kPluginDependNode',
  u'ilrBasicPhotonShader': 'kPluginDependNode',
  u'ilrBssrdfShader': 'kPluginDependNode',
  u'ilrDielectricPhotonShader': 'kPluginDependNode',
  u'ilrDielectricShader': 'kPluginDependNode',
  u'ilrHwBakeVisualizer': 'kPluginHwShaderNode',
  u'ilrLuaNode': 'kPluginDependNode',
  u'ilrNormalMap': 'kPluginDependNode',
  u'ilrOccData': 'kPluginDependNode',
  u'ilrOccSampler': 'kPluginDependNode',
  u'ilrOptionsNode': 'kPluginDependNode',
  u'ilrOrenNayarShader': 'kPluginDependNode',
  u'ilrOutputShaderBackendNode': 'kPluginDependNode',
  u'ilrPhysicPhotonShader': 'kPluginDependNode',
  u'ilrPointCloudShape': 'kPluginShape',
  u'ilrPolyColorPerVertex': 'kPluginDependNode',
  u'ilrRaySampler': 'kPluginDependNode',
  u'ilrShadowMask': 'kPluginDependNode',
  u'ilrSurfaceThickness': 'kPluginDependNode',
  u'ilrUIOptionsNode': 'kPluginDependNode',
  u'ilrUVMappingVisualizer': 'kPluginDependNode',
  u'imagePlane': 'kImagePlane',
  u'imageSource': u'kImageSource',
  u'implicitBox': 'kBox',
  u'implicitCone': 'kImplicitCone',
  u'implicitSphere': 'kImplicitSphere',
  u'insertKnotCurve': 'kInsertKnotCrv',
  u'insertKnotSurface': 'kInsertKnotSrf',
  u'instancer': 'kInstancer',
  u'intersectSurface': 'kIntersectSurface',
  u'inverseMatrix': 'kPluginDependNode',
  u'jiggle': 'kJiggleDeformer',
  u'joint': 'kJoint',
  u'jointCluster': 'kJointCluster',
  u'jointFfd': 'kFfdDualBase',
  u'jointLattice': 'kBendLattice',
  u'keyingGroup': 'kKeyingGroup',
  u'lambert': 'kLambert',
  u'lattice': 'kLattice',
  u'layeredShader': 'kLayeredShader',
  u'layeredTexture': 'kLayeredTexture',
  u'leastSquaresModifier': 'kLeastSquares',
  u'leather': 'kLeather',
  u'light': u'kLight',
  u'lightEditor': 'kPluginDependNode',
  u'lightEditorGroup': 'kPluginDependNode',
  u'lightEditorItem': 'kPluginDependNode',
  u'lightEditorLight': 'kPluginDependNode',
  u'lightFog': 'kLightFogMaterial',
  u'lightInfo': 'kLightInfo',
  u'lightLinker': 'kLightLink',
  u'lightList': 'kLightList',
  u'lightsChildCollection': 'kPluginDependNode',
  u'lightsCollection': 'kPluginDependNode',
  u'lineModifier': 'kLineModifier',
  u'listItem': 'kPluginDependNode',
  u'locator': 'kLocator',
  u'lodGroup': 'kLodGroup',
  u'lodThresholds': 'kLodThresholds',
  u'loft': 'kSkin',
  u'lookAt': 'kLookAt',
  u'luminance': 'kLuminance',
  u'makeCircularArc': 'kCreate',
  u'makeGroup': 'kMakeGroup',
  u'makeIllustratorCurves': 'kIllustratorCurve',
  u'makeNurbCircle': 'kCircle',
  u'makeNurbCone': 'kCone',
  u'makeNurbCube': 'kNurbsCube',
  u'makeNurbCylinder': 'kCylinder',
  u'makeNurbPlane': 'kNurbsPlane',
  u'makeNurbSphere': 'kSphere',
  u'makeNurbTorus': 'kTorus',
  u'makeNurbsSquare': 'kNurbsSquare',
  u'makeTextCurves': 'kTextCurves',
  u'makeThreePointCircularArc': 'kNurbsCircular3PtArc',
  u'makeTwoPointCircularArc': 'kNurbsCircular2PtArc',
  u'mandelbrot': 'kMandelbrot',
  u'mandelbrot3D': 'kMandelbrot3D',
  u'marble': 'kMarble',
  u'materialFacade': 'kMaterialFacade',
  u'materialInfo': 'kMaterialInfo',
  u'materialOverride': 'kPluginDependNode',
  u'membrane': 'kMembrane',
  u'mesh': 'kMesh',
  u'meshVarGroup': 'kMeshVarGroup',
  u'motionPath': 'kMotionPath',
  u'motionTrail': 'kSnapshotPath',
  u'motionTrailShape': 'kSnapshot',
  u'mountain': 'kMountain',
  'moveVertexManip': 'kMoveVertexManip',
  u'movie': 'kFileTexture',
  u'mpBirailSrf': 'kMPbirailSrf',
  u'multDoubleLinear': 'kMultDoubleLinear',
  u'multMatrix': 'kMatrixMult',
  u'multilisterLight': 'kMultilisterLight',
  u'multiplyDivide': 'kMultiplyDivide',
  u'mute': 'kMute',
  u'nBase': u'kNBase',
  u'nCloth': 'kNCloth',
  u'nComponent': 'kNComponent',
  u'nParticle': 'kNParticle',
  u'nRigid': 'kNRigid',
  u'nearestPointOnCurve': 'kNearestPointOnCurve',
  u'nearestPointOnMesh': 'kPluginDependNode',
  u'network': 'kAffect',
  u'newtonField': 'kNewton',
  'node': 'kDependencyNode',
  u'nodeGraphEditorBookmarkInfo': 'kNodeGraphEditorBookmarkInfo',
  u'nodeGraphEditorBookmarks': 'kNodeGraphEditorBookmarks',
  u'nodeGraphEditorInfo': 'kNodeGraphEditorInfo',
  u'noise': 'kNoise',
  u'nonAmbientLightShapeNode': 'kNonAmbientLight',
  u'nonExtendedLightShapeNode': 'kNonExtendedLight',
  u'nonLinear': 'kNonLinear',
  u'normalConstraint': 'kNormalConstraint',
  u'nucleus': 'kNucleus',
  u'nurbsCurve': 'kNurbsCurve',
  u'nurbsCurveToBezier': 'kNurbsCurveToBezier',
  u'nurbsDimShape': 'kDimension',
  u'nurbsSurface': 'kNurbsSurface',
  u'nurbsTessellate': 'kNurbsTesselate',
  u'nurbsToSubdiv': 'kNurbsToSubdiv',
  u'nurbsToSubdivProc': 'kNurbsToSubdiv',
  u'objectAttrFilter': 'kObjectAttrFilter',
  u'objectBinFilter': 'kObjectBinFilter',
  u'objectFilter': 'kObjectFilter',
  u'objectGrpToComp': 'kPluginDependNode',
  u'objectMultiFilter': 'kObjectMultiFilter',
  u'objectNameFilter': 'kObjectNameFilter',
  u'objectRenderFilter': 'kObjectRenderFilter',
  u'objectScriptFilter': 'kObjectScriptFilter',
  u'objectSet': 'kSet',
  u'objectTypeFilter': 'kObjectTypeFilter',
  u'ocean': 'kOcean',
  u'oceanShader': 'kOceanShader',
  u'offsetCos': 'kOffsetCos',
  u'offsetCurve': 'kOffsetCurve',
  u'offsetDeformer': 'kPluginDeformerNode',
  u'offsetSurface': 'kOffsetSurface',
  u'oldBlindDataBase': 'kDependencyNode',
  u'oldGeometryConstraint': 'kOldGeometryConstraint',
  u'oldNormalConstraint': 'kNormalConstraint',
  u'oldTangentConstraint': 'kTangentConstraint',
  u'opticalFX': 'kOpticalFX',
  u'orientConstraint': 'kOrientConstraint',
  u'orientationMarker': 'kOrientationMarker',
  u'orthoGrid': u'kOrthoGrid',
  u'override': 'kPluginDependNode',
  u'pairBlend': 'kPairBlend',
  u'paramDimension': 'kParamDimension',
  u'parentConstraint': 'kParentConstraint',
  u'parentTessellate': 'kCreate',
  u'particle': 'kParticle',
  u'particleAgeMapper': 'kParticleAgeMapper',
  u'particleCloud': 'kParticleCloud',
  u'particleColorMapper': 'kParticleColorMapper',
  u'particleIncandMapper': 'kParticleIncandecenceMapper',
  u'particleSamplerInfo': 'kParticleSamplerInfo',
  u'particleTranspMapper': 'kParticleTransparencyMapper',
  u'partition': 'kPartition',
  u'passContributionMap': 'kPassContributionMap',
  u'passMatrix': 'kMatrixPass',
  u'pfxGeometry': u'kPfxGeometry',
  u'pfxHair': 'kPfxHair',
  u'pfxToon': 'kPfxToon',
  u'phong': 'kPhong',
  u'phongE': 'kPhongExplorer',
  u'place2dTexture': 'kPlace2dTexture',
  u'place3dTexture': 'kPlace3dTexture',
  u'planarTrimSurface': 'kPlanarTrimSrf',
  u'plane': u'kPlane',
  u'plusMinusAverage': 'kPlusMinusAverage',
  u'pointConstraint': 'kPointConstraint',
  u'pointEmitter': 'kEmitter',
  u'pointLight': 'kPointLight',
  u'pointMatrixMult': 'kPointMatrixMult',
  u'pointOnCurveInfo': 'kPointOnCurveInfo',
  u'pointOnPolyConstraint': 'kPointOnPolyConstraint',
  u'pointOnSurfaceInfo': 'kPointOnSurfaceInfo',
  u'poleVectorConstraint': 'kPoleVectorConstraint',
  u'polyAppend': 'kPolyAppend',
  u'polyAppendVertex': 'kPolyAppendVertex',
  u'polyAutoProj': 'kPolyAutoProj',
  u'polyAverageVertex': 'kPolyAverageVertex',
  u'polyBase': 'kDependencyNode',
  u'polyBevel': 'kPolyBevel',
  u'polyBevel2': 'kPolyBevel2',
  u'polyBevel3': 'kPolyBevel3',
  u'polyBlindData': 'kPolyBlindData',
  u'polyBoolOp': 'kPolyBoolOp',
  u'polyBridgeEdge': 'kPolyBridgeEdge',
  u'polyCBoolOp': 'kPolyCBoolOp',
  u'polyChipOff': 'kPolyChipOff',
  u'polyCircularize': 'kPolyCircularize',
  u'polyClean': 'kPolyClean',
  u'polyCloseBorder': 'kPolyCloseBorder',
  u'polyCollapseEdge': 'kPolyCollapseEdge',
  u'polyCollapseF': 'kPolyCollapseF',
  u'polyColorDel': 'kPolyColorDel',
  u'polyColorMod': 'kPolyColorMod',
  u'polyColorPerVertex': 'kPolyColorPerVertex',
  u'polyCone': 'kPolyCone',
  u'polyConnectComponents': 'kPolyConnectComponents',
  u'polyContourProj': 'kPolyContourProj',
  u'polyCopyUV': 'kMidModifier',
  u'polyCrease': 'kPolyCreaseEdge',
  u'polyCreaseEdge': 'kPolyCreaseEdge',
  u'polyCreateFace': 'kPolyCreateFacet',
  u'polyCreator': u'kPolyCreator',
  u'polyCube': 'kPolyCube',
  u'polyCut': 'kPolyCut',
  u'polyCylProj': 'kPolyCylProj',
  u'polyCylinder': 'kPolyCylinder',
  u'polyDelEdge': 'kPolyDelEdge',
  u'polyDelFacet': 'kPolyDelFacet',
  u'polyDelVertex': 'kPolyDelVertex',
  u'polyDisc': 'kPluginDependNode',
  u'polyDuplicateEdge': 'kPolyDuplicateEdge',
  u'polyEdgeToCurve': 'kPolyEdgeToCurve',
  u'polyEditEdgeFlow': 'kPolyEditEdgeFlow',
  u'polyExtrudeEdge': 'kPolyExtrudeEdge',
  u'polyExtrudeFace': 'kPolyExtrudeFacet',
  u'polyExtrudeVertex': 'kPolyExtrudeVertex',
  u'polyFlipEdge': 'kPolyFlipEdge',
  u'polyFlipUV': 'kPolyFlipUV',
  u'polyGear': 'kPluginDependNode',
  u'polyHelix': 'kPolyHelix',
  u'polyHoleFace': 'kPolyHoleFace',
  u'polyLayoutUV': 'kPolyLayoutUV',
  u'polyMapCut': 'kPolyMapCut',
  u'polyMapDel': 'kPolyMapDel',
  u'polyMapSew': 'kPolyMapSew',
  u'polyMapSewMove': 'kPolyMapSewMove',
  u'polyMergeEdge': 'kPolyMergeEdge',
  u'polyMergeFace': 'kPolyMergeFacet',
  u'polyMergeUV': 'kPolyMergeUV',
  u'polyMergeVert': 'kPolyMergeVert',
  u'polyMirror': 'kPolyMirror',
  u'polyModifier': 'kDependencyNode',
  u'polyModifierUV': 'kDependencyNode',
  u'polyModifierWorld': 'kDependencyNode',
  u'polyMoveEdge': 'kPolyMoveEdge',
  u'polyMoveFace': 'kPolyMoveFacet',
  u'polyMoveFacetUV': 'kPolyMoveFacetUV',
  u'polyMoveUV': 'kPolyMoveUV',
  u'polyMoveVertex': 'kPolyMoveVertex',
  u'polyNormal': 'kPolyNormal',
  u'polyNormalPerVertex': 'kPolyNormalPerVertex',
  u'polyNormalizeUV': 'kPolyNormalizeUV',
  u'polyOptUvs': 'kMidModifier',
  u'polyPassThru': 'kPolyPassThru',
  u'polyPinUV': 'kPolyPinUV',
  u'polyPipe': 'kPolyPipe',
  u'polyPlanarProj': 'kPolyPlanProj',
  u'polyPlane': 'kPolyMesh',
  u'polyPlatonic': 'kPluginDependNode',
  u'polyPlatonicSolid': 'kPolyPlatonicSolid',
  u'polyPoke': 'kPolyPoke',
  u'polyPrimitive': u'kPolyPrimitive',
  u'polyPrimitiveMisc': 'kPolyPrimitiveMisc',
  u'polyPrism': 'kPolyPrism',
  u'polyProj': 'kPolyProj',
  u'polyProjectCurve': 'kPolyProjectCurve',
  u'polyPyramid': 'kPolyPyramid',
  u'polyQuad': 'kPolyQuad',
  u'polyReForm': 'kReForm',
  u'polyReduce': 'kPolyReduce',
  u'polyRemesh': 'kPolyRemesh',
  u'polySeparate': 'kPolySeparate',
  u'polySewEdge': 'kPolySewEdge',
  u'polySmooth': 'kPolySmooth',
  u'polySmoothFace': 'kPolySmoothFacet',
  u'polySmoothProxy': 'kPolySmoothProxy',
  u'polySoftEdge': 'kPolySoftEdge',
  u'polySphProj': 'kPolySphProj',
  u'polySphere': 'kPolySphere',
  u'polySpinEdge': 'kPolySpinEdge',
  u'polySplit': 'kPolySplit',
  u'polySplitEdge': 'kPolySplitEdge',
  u'polySplitRing': 'kPolySplitRing',
  u'polySplitVert': 'kPolySplitVert',
  u'polyStraightenUVBorder': 'kPolyStraightenUVBorder',
  u'polySubdEdge': 'kPolySubdEdge',
  u'polySubdFace': 'kPolySubdFacet',
  u'polySuperShape': 'kPluginDependNode',
  u'polyTerrain': 'kPluginLocatorNode',
  u'polyToSubdiv': 'kPolyToSubdiv',
  u'polyTorus': 'kPolyTorus',
  u'polyTransfer': 'kPolyTransfer',
  u'polyTriangulate': 'kPolyTriangulate',
  u'polyTweak': 'kPolyTweak',
  u'polyTweakUV': 'kPolyTweakUV',
  u'polyUVRectangle': 'kPolyUVRectangle',
  u'polyUnite': 'kPolyUnite',
  u'polyWedgeFace': 'kPolyWedgeFace',
  u'poseInterpolator': 'kPluginLocatorNode',
  u'poseInterpolatorManager': 'kPoseInterpolatorManager',
  u'positionMarker': 'kPositionMarker',
  u'postProcessList': 'kPostProcessList',
  u'precompExport': 'kPrecompExport',
  u'premultiply': 'kPluginDependNode',
  u'primitive': u'kPrimitive',
  u'projectCurve': 'kProjectCurve',
  u'projectTangent': 'kProjectTangent',
  u'projection': 'kProjection',
  u'proxWrap': 'kProxWrap',
  u'proxyManager': 'kProxyManager',
  u'psdFileTex': 'kPsdFileTexture',
  u'quadShadingSwitch': 'kQuadShadingSwitch',
  u'quatAdd': 'kPluginDependNode',
  u'quatConjugate': 'kPluginDependNode',
  u'quatInvert': 'kPluginDependNode',
  u'quatNegate': 'kPluginDependNode',
  u'quatNormalize': 'kPluginDependNode',
  u'quatProd': 'kPluginDependNode',
  u'quatSub': 'kPluginDependNode',
  u'quatToEuler': 'kPluginDependNode',
  u'radialField': 'kRadial',
  u'ramp': 'kRamp',
  u'rampShader': 'kRampShader',
  u'rbfSrf': 'kRBFsurface',
  u'rebuildCurve': 'kRebuildCurve',
  u'rebuildSurface': 'kRebuildSurface',
  u'record': 'kRecord',
  u'reference': 'kReference',
  u'reflect': u'kReflect',
  u'relOverride': 'kPluginDependNode',
  u'relUniqueOverride': 'kPluginDependNode',
  u'remapColor': 'kRemapColor',
  u'remapHsv': 'kRemapHsv',
  u'remapValue': 'kRemapValue',
  u'renderBox': 'kRenderBox',
  u'renderCone': 'kRenderCone',
  u'renderGlobals': 'kRenderGlobals',
  u'renderGlobalsList': 'kRenderGlobalsList',
  u'renderLayer': 'kRenderLayer',
  u'renderLayerManager': 'kRenderLayerManager',
  u'renderLight': u'kLight',
  u'renderPass': 'kRenderPass',
  u'renderPassSet': 'kRenderPassSet',
  u'renderQuality': 'kRenderQuality',
  u'renderRect': 'kRenderRect',
  u'renderSettingsChildCollection': 'kPluginDependNode',
  u'renderSettingsCollection': 'kPluginDependNode',
  u'renderSetup': 'kPluginDependNode',
  u'renderSetupLayer': 'kPluginDependNode',
  u'renderSphere': 'kRenderSphere',
  u'renderTarget': 'kRenderTarget',
  u'renderedImageSource': 'kRenderedImageSource',
  u'reorderUVSet': 'kReorderUVSet',
  u'resolution': 'kResolution',
  u'resultCurve': u'kResultCurve',
  u'resultCurveTimeToAngular': 'kResultCurveTimeToAngular',
  u'resultCurveTimeToLinear': 'kResultCurveTimeToDistance',
  u'resultCurveTimeToTime': 'kResultCurveTimeToTime',
  u'resultCurveTimeToUnitless': 'kResultCurveTimeToUnitless',
  u'reverse': 'kReverse',
  u'reverseCurve': 'kReverseCurve',
  u'reverseSurface': 'kReverseSurface',
  u'revolve': 'kRevolve',
  u'revolvedPrimitive': u'kRevolvedPrimitive',
  u'rgbToHsv': 'kRgbToHsv',
  u'rigidBody': 'kRigid',
  u'rigidConstraint': 'kRigidConstraint',
  u'rigidSolver': 'kRigidSolver',
  u'rock': 'kRock',
  u'rotateHelper': 'kPluginDependNode',
  u'roundConstantRadius': 'kRoundConstantRadius',
  u'sampler': 'kTime',
  u'samplerInfo': 'kSamplerInfo',
  u'scaleConstraint': 'kScaleConstraint',
  u'script': 'kScript',
  u'sculpt': 'kSculpt',
  u'selectionListOperator': 'kSelectionListOperator',
  u'selector': 'kPluginDependNode',
  u'sequenceManager': 'kSequenceManager',
  u'sequencer': 'kSequencer',
  u'setRange': 'kSetRange',
  u'shaderGlow': 'kShaderGlow',
  u'shaderOverride': 'kPluginDependNode',
  u'shadingDependNode': 'kDependencyNode',
  u'shadingEngine': 'kShadingEngine',
  u'shadingMap': 'kShadingMap',
  u'shape': u'kShape',
  u'shapeEditorManager': 'kShapeEditorManager',
  u'shellDeformer': 'kPluginDeformerNode',
  u'shellTessellate': 'kNurbsTesselate',
  u'shot': 'kShot',
  u'shrinkWrap': 'kShrinkWrapFilter',
  u'simpleSelector': 'kPluginDependNode',
  u'simpleTestNode': 'kDependencyNode',
  u'simpleVolumeShader': 'kSimpleVolumeShader',
  u'simplexNoise': 'kPluginDependNode',
  u'singleShadingSwitch': 'kSingleShadingSwitch',
  u'sketchPlane': 'kSketchPlane',
  u'skinBinding': 'kSkinBinding',
  u'skinCluster': 'kSkinClusterFilter',
  'smear': 'kSmear',
  u'smoothCurve': 'kSmoothCurve',
  u'smoothTangentSrf': 'kSmoothTangentSrf',
  u'snapshot': 'kSnapshotPath',
  u'snapshotShape': 'kSnapshot',
  u'snow': 'kSnow',
  u'softMod': 'kSoftModFilter',
  u'softModHandle': 'kSoftMod',
  u'solidFractal': 'kSolidFractal',
  u'spBirailSrf': 'kSPbirailSrf',
  u'spotLight': 'kSpotLight',
  u'spring': 'kSpring',
  u'squareSrf': 'kSquareSrf',
  u'stencil': 'kStencil',
  u'stereoRigCamera': 'kStereoCameraMaster',
  u'stereoRigFrustum': 'kPluginLocatorNode',
  u'stereoRigTransform': 'kPluginTransformNode',
  u'stitchAsNurbsShell': 'kStitchAsNurbsShell',
  u'stitchSrf': 'kStitchSrf',
  u'stroke': 'kStroke',
  u'strokeGlobals': 'kStrokeGlobals',
  u'stucco': 'kStucco',
  u'studioClearCoat': 'kStudioClearCoat',
  u'styleCurve': 'kStyleCurve',
  u'subCurve': 'kSubCurve',
  u'subSurface': 'kSubSurface',
  u'subdAddTopology': 'kSubdAddTopology',
  u'subdAutoProj': 'kSubdAutoProj',
  u'subdBase': 'kDependencyNode',
  u'subdBlindData': 'kSubdBlindData',
  u'subdCleanTopology': 'kSubdCleanTopology',
  u'subdHierBlind': 'kSubdHierBlind',
  u'subdLayoutUV': 'kSubdLayoutUV',
  u'subdMapCut': 'kSubdMapCut',
  u'subdMapSewMove': 'kSubdMapSewMove',
  u'subdModifier': u'kSubdModifier',
  u'subdModifierUV': u'kSubdModifier',
  u'subdModifierWorld': u'kSubdModifier',
  u'subdPlanarProj': 'kSubdPlanProj',
  u'subdTweak': 'kSubdTweak',
  u'subdTweakUV': 'kSubdTweakUV',
  u'subdiv': 'kSubdiv',
  u'subdivCollapse': 'kSubdivCollapse',
  u'subdivComponentId': 'kSubdivCompId',
  u'subdivReverseFaces': 'kSubdivReverseFaces',
  u'subdivSurfaceVarGroup': 'kSurfaceVarGroup',
  u'subdivToNurbs': 'kSubdivToNurbs',
  u'subdivToPoly': 'kSubdivToPoly',
  u'substance': 'kPluginDependNode',
  u'substanceOutput': 'kPluginDependNode',
  u'surfaceInfo': 'kSurfaceInfo',
  u'surfaceLuminance': 'kSurfaceLuminance',
  u'surfaceShader': 'kSurfaceShader',
  u'surfaceShape': 'kSurface',
  u'surfaceVarGroup': 'kSurfaceVarGroup',
  u'svgToPoly': 'kPluginDependNode',
  u'symmetryConstraint': 'kSymmetryConstraint',
  u'tangentConstraint': 'kTangentConstraint',
  u'tension': 'kTension',
  u'terrainLayerNode': 'kPluginLocatorNode',
  u'texLattice': 'kTexLattice',
  u'texture2d': u'kTexture2d',
  u'texture3d': u'kTexture3d',
  u'textureBakeSet': 'kTextureBakeSet',
  u'textureDeformer': 'kTextureDeformer',
  u'textureDeformerHandle': 'kTextureDeformerHandle',
  u'textureEnv': u'kTextureEnv',
  u'textureToGeom': 'kDependencyNode',
  u'threadedDevice': u'kThreadedDevice',
  u'time': 'kTime',
  u'timeEditor': 'kTimeEditor',
  u'timeEditorAnimSource': 'kTimeEditorAnimSource',
  u'timeEditorClip': 'kTimeEditorClip',
  u'timeEditorClipBase': 'kTimeEditorClipBase',
  u'timeEditorClipEvaluator': 'kTimeEditorClipEvaluator',
  u'timeEditorInterpolator': 'kTimeEditorInterpolator',
  u'timeEditorTracks': 'kTimeEditorTracks',
  u'timeFunction': 'kTimeFunction',
  u'timeToUnitConversion': 'kTimeToUnitConversion',
  u'timeWarp': 'kTimeWarp',
  u'toonLineAttributes': 'kToonLineAttributes',
  u'trackInfoManager': 'kTrackInfoManager',
  u'transferAttributes': 'kTransferAttributes',
  u'transform': 'kTransform',
  u'transformGeometry': 'kTransformGeometry',
  u'transposeMatrix': 'kPluginDependNode',
  u'trim': 'kTrim',
  u'trimWithBoundaries': 'kTrimWithBoundaries',
  u'tripleShadingSwitch': 'kTripleShadingSwitch',
  u'turbulenceField': 'kTurbulence',
  u'tweak': 'kTweak',
  u'type': 'kPluginDependNode',
  u'typeExtrude': 'kPluginDependNode',
  u'uniformField': 'kUniform',
  u'unitConversion': 'kUnitConversion',
  u'unitToTimeConversion': 'kUnitToTimeConversion',
  u'unknown': 'kUnknown',
  u'unknownDag': 'kUnknownDag',
  u'unknownTransform': 'kUnknownTransform',
  u'unpremultiply': 'kPluginDependNode',
  u'untrim': 'kUntrim',
  u'useBackground': 'kUseBackground',
  u'uvChooser': 'kUvChooser',
  u'valueOverride': 'kPluginDependNode',
  u'vectorAdjust': 'kPluginDeformerNode',
  u'vectorExtrude': 'kPluginDependNode',
  u'vectorProduct': 'kVectorProduct',
  'vectorRenderGlobals': 'kDependencyNode',
  u'vertexBakeSet': 'kVertexBakeSet',
  u'viewColorManager': 'kViewColorManager',
  u'volumeAxisField': 'kVolumeAxis',
  u'volumeFog': 'kVolumeFog',
  u'volumeLight': 'kVolumeLight',
  u'volumeNoise': 'kVolumeNoise',
  u'volumeShader': 'kVolumeShader',
  u'vortexField': 'kVortex',
  u'water': 'kWater',
  u'weightGeometryFilter': 'kWeightGeometryFilt',
  u'wire': 'kWire',
  u'wood': 'kWood',
  u'wrap': 'kWrapFilter',
  u'wtAddMatrix': 'kMatrixWtAdd',
  'xformManip': 'kXformManip',
  u'xgmArchiveGuide': 'kPluginShape',
  u'xgmCardGuide': 'kPluginShape',
  u'xgmConnectivity': 'kPluginLocatorNode',
  u'xgmCurveToSpline': 'kPluginDependNode',
  u'xgmDescription': 'kPluginShape',
  u'xgmGuide': 'kPluginShape',
  u'xgmHairMapping': 'kPluginDependNode',
  u'xgmMakeGuide': 'kPluginDependNode',
  u'xgmModifierBase': 'kPluginDependNode',
  u'xgmModifierClump': 'kPluginDependNode',
  u'xgmModifierCollision': 'kPluginDependNode',
  u'xgmModifierCut': 'kPluginDependNode',
  u'xgmModifierDisplacement': 'kPluginDependNode',
  u'xgmModifierGuide': 'kPluginDependNode',
  u'xgmModifierLinearWire': 'kPluginDependNode',
  u'xgmModifierNoise': 'kPluginDependNode',
  u'xgmModifierScale': 'kPluginDependNode',
  u'xgmModifierSculpt': 'kPluginDependNode',
  u'xgmNurbsPatch': 'kPluginShape',
  u'xgmPalette': 'kPluginTransformNode',
  u'xgmPatch': 'kPluginShape',
  u'xgmPointsViewer': 'kPluginLocatorNode',
  u'xgmSeExpr': 'kPluginDependNode',
  u'xgmSphereGuide': 'kPluginShape',
  u'xgmSplineBase': 'kPluginDependNode',
  u'xgmSplineCache': 'kPluginDependNode',
  u'xgmSplineDescription': 'kPluginShape',
  u'xgmSplineGuide': 'kPluginShape',
  u'xgmSubdPatch': 'kPluginShape'},
 {'kAISEnvFacade': 'maya.OpenMaya.MFnDependencyNode',
  'kAddDoubleLinear': 'maya.OpenMaya.MFnDependencyNode',
  'kAdskMaterial': 'maya.OpenMaya.MFnDependencyNode',
  'kAffect': 'maya.OpenMaya.MFnDependencyNode',
  'kAimConstraint': 'maya.OpenMaya.MFnTransform',
  'kAir': 'maya.OpenMayaFX.MFnAirField',
  'kAlignCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kAlignSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kAmbientLight': 'maya.OpenMaya.MFnAmbientLight',
  'kAngle': 'maya.OpenMaya.MFnDagNode',
  'kAngleBetween': 'maya.OpenMaya.MFnDependencyNode',
  'kAnimBlend': 'maya.OpenMaya.MFnDependencyNode',
  'kAnimBlendInOut': 'maya.OpenMaya.MFnDependencyNode',
  'kAnimCurve': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveTimeToAngular': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveTimeToDistance': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveTimeToTime': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveTimeToUnitless': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveUnitlessToAngular': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveUnitlessToDistance': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveUnitlessToTime': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimCurveUnitlessToUnitless': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kAnimLayer': 'maya.OpenMaya.MFnSet',
  'kAnisotropy': 'maya.OpenMaya.MFnAnisotropyShader',
  'kAnnotation': 'maya.OpenMaya.MFnDagNode',
  'kAnyGeometryVarGroup': 'maya.OpenMaya.MFnTransform',
  'kArcLength': 'maya.OpenMaya.MFnDagNode',
  'kAreaLight': 'maya.OpenMaya.MFnAreaLight',
  'kArrayMapper': 'maya.OpenMaya.MFnDependencyNode',
  'kArubaTesselate': 'maya.OpenMaya.MFnDependencyNode',
  'kAssembly': 'maya.OpenMaya.MFnAssembly',
  'kAttachCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kAttachSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kAttribute': 'maya.OpenMaya.MFnAttribute',
  'kAudio': 'maya.OpenMaya.MFnDependencyNode',
  'kAvgCurves': 'maya.OpenMaya.MFnDependencyNode',
  'kAvgNurbsSurfacePoints': 'maya.OpenMaya.MFnDependencyNode',
  'kAvgSurfacePoints': 'maya.OpenMaya.MFnDependencyNode',
  'kBase': 'maya.OpenMaya.MFnBase',
  'kBaseLattice': 'maya.OpenMaya.MFnDagNode',
  'kBendLattice': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kBevel': 'maya.OpenMaya.MFnDependencyNode',
  'kBevelPlus': 'maya.OpenMaya.MFnDependencyNode',
  'kBezierCurveToNurbs': 'maya.OpenMaya.MFnDependencyNode',
  u'kBirailSrf': 'maya.OpenMaya.MFnDependencyNode',
  u'kBlend': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendColorSet': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendColors': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendDevice': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeAdditiveRotation': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeAdditiveScale': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeBoolean': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeDouble': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeDoubleAngle': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeDoubleLinear': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeEnum': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeFloat': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeFloatAngle': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeFloatLinear': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeInt16': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeInt32': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendNodeTime': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendShape': 'maya.OpenMayaAnim.MFnBlendShapeDeformer',
  'kBlendTwoAttr': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendWeighted': 'maya.OpenMaya.MFnDependencyNode',
  'kBlindDataTemplate': 'maya.OpenMaya.MFnDependencyNode',
  'kBlinn': 'maya.OpenMaya.MFnBlinnShader',
  'kBoundary': 'maya.OpenMaya.MFnDependencyNode',
  'kBox': 'maya.OpenMaya.MFnDagNode',
  'kBrownian': 'maya.OpenMaya.MFnDependencyNode',
  'kBrush': 'maya.OpenMaya.MFnDependencyNode',
  'kBulge': 'maya.OpenMaya.MFnDependencyNode',
  'kBulgeLattice': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kBump': 'maya.OpenMaya.MFnDependencyNode',
  'kBump3d': 'maya.OpenMaya.MFnDependencyNode',
  u'kCacheBase': 'maya.OpenMaya.MFnDependencyNode',
  'kCacheFile': 'maya.OpenMaya.MFnDependencyNode',
  'kCacheTrack': 'maya.OpenMaya.MFnDependencyNode',
  'kCamera': 'maya.OpenMaya.MFnCamera',
  'kCameraSet': 'maya.OpenMaya.MFnCameraSet',
  'kCameraView': 'maya.OpenMaya.MFnDependencyNode',
  'kCharacter': 'maya.OpenMayaAnim.MFnCharacter',
  'kCharacterMap': 'maya.OpenMaya.MFnDependencyNode',
  'kCharacterOffset': 'maya.OpenMaya.MFnDependencyNode',
  'kChecker': 'maya.OpenMaya.MFnDependencyNode',
  'kChoice': 'maya.OpenMaya.MFnDependencyNode',
  'kChooser': 'maya.OpenMaya.MFnDependencyNode',
  'kCircle': 'maya.OpenMaya.MFnDependencyNode',
  'kCircleSweepManip': 'maya.OpenMayaUI.MFnCircleSweepManip',
  'kClampColor': 'maya.OpenMaya.MFnDependencyNode',
  u'kClientDevice': 'maya.OpenMaya.MFnDependencyNode',
  'kClip': 'maya.OpenMayaAnim.MFnClip',
  'kClipGhostShape': 'maya.OpenMaya.MFnTransform',
  'kClipLibrary': 'maya.OpenMaya.MFnDependencyNode',
  'kClipScheduler': 'maya.OpenMaya.MFnDependencyNode',
  'kClipToGhostData': 'maya.OpenMaya.MFnDependencyNode',
  'kCloseCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kCloseSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kClosestPointOnMesh': 'maya.OpenMaya.MFnDependencyNode',
  'kClosestPointOnSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kCloth': 'maya.OpenMaya.MFnDependencyNode',
  'kCloud': 'maya.OpenMaya.MFnDependencyNode',
  'kCluster': 'maya.OpenMaya.MFnDagNode',
  'kClusterFilter': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kClusterFlexor': 'maya.OpenMaya.MFnDagNode',
  'kCollision': 'maya.OpenMaya.MFnTransform',
  'kColorMgtGlobals': 'maya.OpenMaya.MFnDependencyNode',
  'kColorProfile': 'maya.OpenMaya.MFnDependencyNode',
  'kCombinationShape': 'maya.OpenMaya.MFnDependencyNode',
  'kComponent': 'maya.OpenMaya.MFnComponent',
  'kComponentListData': 'maya.OpenMaya.MFnComponentListData',
  'kCompoundAttribute': 'maya.OpenMaya.MFnCompoundAttribute',
  'kCondition': 'maya.OpenMaya.MFnDependencyNode',
  'kCone': 'maya.OpenMaya.MFnDependencyNode',
  u'kConstraint': 'maya.OpenMaya.MFnTransform',
  'kContainer': 'maya.OpenMaya.MFnContainerNode',
  'kContainerBase': 'maya.OpenMaya.MFnDependencyNode',
  'kContrast': 'maya.OpenMaya.MFnDependencyNode',
  'kControllerTag': 'maya.OpenMaya.MFnDependencyNode',
  'kCopyColorSet': 'maya.OpenMaya.MFnDependencyNode',
  'kCopyUVSet': 'maya.OpenMaya.MFnDependencyNode',
  'kCrater': 'maya.OpenMaya.MFnDependencyNode',
  'kCreaseSet': 'maya.OpenMaya.MFnSet',
  'kCreate': 'maya.OpenMaya.MFnDependencyNode',
  'kCreateColorSet': 'maya.OpenMaya.MFnDependencyNode',
  'kCreateUVSet': 'maya.OpenMaya.MFnDependencyNode',
  'kCurve': 'maya.OpenMaya.MFnDagNode',
  'kCurveCurveIntersect': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveFromMeshCoM': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveFromMeshEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveFromSubdivEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveFromSubdivFace': 'maya.OpenMaya.MFnDependencyNode',
  u'kCurveFromSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveFromSurfaceBnd': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveFromSurfaceCoS': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveFromSurfaceIso': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveNormalizerAngle': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveNormalizerLinear': 'maya.OpenMaya.MFnDependencyNode',
  'kCurveSegmentManip': 'maya.OpenMayaUI.MFnCurveSegmentManip',
  'kCurveVarGroup': 'maya.OpenMaya.MFnTransform',
  'kCylinder': 'maya.OpenMaya.MFnDependencyNode',
  'kDOF': 'maya.OpenMaya.MFnDependencyNode',
  'kDPbirailSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kDagContainer': 'maya.OpenMaya.MFnTransform',
  'kDagNode': 'maya.OpenMaya.MFnDagNode',
  'kDagPose': 'maya.OpenMaya.MFnDependencyNode',
  'kData': 'maya.OpenMaya.MFnData',
  'kDefaultLightList': 'maya.OpenMaya.MFnDependencyNode',
  'kDeformBend': 'maya.OpenMaya.MFnDagNode',
  'kDeformFlare': 'maya.OpenMaya.MFnDagNode',
  u'kDeformFunc': 'maya.OpenMaya.MFnDagNode',
  'kDeformSine': 'maya.OpenMaya.MFnDagNode',
  'kDeformSquash': 'maya.OpenMaya.MFnDagNode',
  'kDeformTwist': 'maya.OpenMaya.MFnDagNode',
  'kDeformWave': 'maya.OpenMaya.MFnDagNode',
  'kDeleteColorSet': 'maya.OpenMaya.MFnDependencyNode',
  'kDeleteComponent': 'maya.OpenMaya.MFnDependencyNode',
  'kDeleteUVSet': 'maya.OpenMaya.MFnDependencyNode',
  'kDeltaMush': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kDependencyNode': 'maya.OpenMaya.MFnDependencyNode',
  'kDetachCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kDetachSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kDimension': 'maya.OpenMaya.MFnDagNode',
  'kDirectedDisc': 'maya.OpenMaya.MFnDagNode',
  'kDirectionManip': 'maya.OpenMayaUI.MFnDirectionManip',
  'kDirectionalLight': 'maya.OpenMaya.MFnDirectionalLight',
  'kDiscManip': 'maya.OpenMayaUI.MFnDiscManip',
  'kDiskCache': 'maya.OpenMaya.MFnDependencyNode',
  'kDisplacementShader': 'maya.OpenMaya.MFnDependencyNode',
  'kDisplayLayer': 'maya.OpenMaya.MFnDependencyNode',
  'kDisplayLayerManager': 'maya.OpenMaya.MFnDependencyNode',
  'kDistance': 'maya.OpenMaya.MFnDagNode',
  'kDistanceBetween': 'maya.OpenMaya.MFnDependencyNode',
  'kDistanceManip': 'maya.OpenMayaUI.MFnDistanceManip',
  'kDoubleArrayData': 'maya.OpenMaya.MFnDoubleArrayData',
  'kDoubleIndexedComponent': 'maya.OpenMaya.MFnDoubleIndexedComponent',
  'kDoubleShadingSwitch': 'maya.OpenMaya.MFnDependencyNode',
  'kDrag': 'maya.OpenMayaFX.MFnDragField',
  'kDropoffLocator': 'maya.OpenMaya.MFnDagNode',
  'kDummy': 'maya.OpenMaya.MFnDagNode',
  'kDynArrayAttrsData': 'maya.OpenMaya.MFnArrayAttrsData',
  u'kDynBase': 'maya.OpenMaya.MFnTransform',
  'kDynGlobals': 'maya.OpenMaya.MFnDependencyNode',
  'kDynSweptGeometryData': 'maya.OpenMayaFX.MFnDynSweptGeometryData',
  'kDynamicConstraint': 'maya.OpenMaya.MFnDagNode',
  'kDynamicsController': 'maya.OpenMaya.MFnDependencyNode',
  'kEditMetadata': 'maya.OpenMaya.MFnDependencyNode',
  'kEditsManager': 'maya.OpenMaya.MFnDependencyNode',
  'kEmitter': 'maya.OpenMaya.MFnTransform',
  'kEnumAttribute': 'maya.OpenMaya.MFnEnumAttribute',
  'kEnvBall': 'maya.OpenMaya.MFnDependencyNode',
  'kEnvChrome': 'maya.OpenMaya.MFnDependencyNode',
  'kEnvCube': 'maya.OpenMaya.MFnDependencyNode',
  'kEnvFacade': 'maya.OpenMaya.MFnDependencyNode',
  'kEnvFogMaterial': 'maya.OpenMaya.MFnDependencyNode',
  'kEnvFogShape': 'maya.OpenMaya.MFnDagNode',
  'kEnvSky': 'maya.OpenMaya.MFnDependencyNode',
  'kEnvSphere': 'maya.OpenMaya.MFnDependencyNode',
  'kExplodeNurbsShell': 'maya.OpenMaya.MFnDependencyNode',
  'kExpression': 'maya.OpenMaya.MFnExpression',
  'kExtendCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kExtendSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kExtrude': 'maya.OpenMaya.MFnDependencyNode',
  'kFFD': 'maya.OpenMayaAnim.MFnLatticeDeformer',
  'kFFblendSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kFFfilletSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kFacade': 'maya.OpenMaya.MFnDependencyNode',
  'kFfdDualBase': 'maya.OpenMaya.MFnDependencyNode',
  'kField': 'maya.OpenMayaFX.MFnField',
  'kFileTexture': 'maya.OpenMaya.MFnDependencyNode',
  'kFilletCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kFitBspline': 'maya.OpenMaya.MFnDependencyNode',
  'kFlexor': 'maya.OpenMaya.MFnDagNode',
  'kFloatArrayData': 'maya.OpenMaya.MFnFloatArrayData',
  'kFlow': 'maya.OpenMaya.MFnDependencyNode',
  'kFluid': 'maya.OpenMayaFX.MFnFluid',
  'kFluidEmitter': 'maya.OpenMaya.MFnTransform',
  'kFluidTexture2D': 'maya.OpenMayaFX.MFnFluid',
  'kFluidTexture3D': 'maya.OpenMayaFX.MFnFluid',
  'kFollicle': 'maya.OpenMaya.MFnDagNode',
  'kFosterParent': 'maya.OpenMaya.MFnTransform',
  'kFourByFourMatrix': 'maya.OpenMaya.MFnDependencyNode',
  'kFractal': 'maya.OpenMaya.MFnDependencyNode',
  'kFreePointTriadManip': 'maya.OpenMayaUI.MFnFreePointTriadManip',
  'kGammaCorrect': 'maya.OpenMaya.MFnDependencyNode',
  'kGenericAttribute': 'maya.OpenMaya.MFnGenericAttribute',
  'kGeoConnectable': 'maya.OpenMaya.MFnDagNode',
  'kGeoConnector': 'maya.OpenMaya.MFnDependencyNode',
  'kGeomBind': 'maya.OpenMaya.MFnDependencyNode',
  'kGeometryConstraint': 'maya.OpenMaya.MFnTransform',
  'kGeometryData': 'maya.OpenMaya.MFnGeometryData',
  'kGeometryFilt': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kGlobalCacheControls': 'maya.OpenMaya.MFnDependencyNode',
  'kGlobalStitch': 'maya.OpenMaya.MFnDependencyNode',
  'kGranite': 'maya.OpenMaya.MFnDependencyNode',
  'kGravity': 'maya.OpenMayaFX.MFnGravityField',
  'kGreasePencilSequence': 'maya.OpenMaya.MFnDependencyNode',
  'kGreasePlane': 'maya.OpenMaya.MFnDagNode',
  'kGreasePlaneRenderShape': 'maya.OpenMaya.MFnMesh',
  'kGrid': 'maya.OpenMaya.MFnDependencyNode',
  u'kGroundPlane': 'maya.OpenMaya.MFnDagNode',
  'kGroupId': 'maya.OpenMaya.MFnDependencyNode',
  'kGroupParts': 'maya.OpenMaya.MFnDependencyNode',
  'kGuide': 'maya.OpenMaya.MFnDependencyNode',
  'kHairConstraint': 'maya.OpenMaya.MFnDagNode',
  'kHairSystem': 'maya.OpenMaya.MFnDagNode',
  'kHairTubeShader': 'maya.OpenMaya.MFnReflectShader',
  'kHardenPointCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kHardwareReflectionMap': 'maya.OpenMaya.MFnDependencyNode',
  'kHardwareRenderGlobals': 'maya.OpenMaya.MFnDependencyNode',
  'kHardwareRenderingGlobals': 'maya.OpenMaya.MFnDependencyNode',
  'kHeightField': 'maya.OpenMaya.MFnDagNode',
  'kHikEffector': 'maya.OpenMayaAnim.MFnHikEffector',
  'kHikFKJoint': 'maya.OpenMayaAnim.MFnIkJoint',
  'kHikFloorContactMarker': 'maya.OpenMaya.MFnDagNode',
  'kHikGroundPlane': 'maya.OpenMaya.MFnTransform',
  'kHikHandle': 'maya.OpenMaya.MFnTransform',
  'kHikIKEffector': 'maya.OpenMaya.MFnTransform',
  'kHikSolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kHistorySwitch': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kHsvToRgb': 'maya.OpenMaya.MFnDependencyNode',
  'kHwShaderNode': 'maya.OpenMaya.MFnDependencyNode',
  'kHyperGraphInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kHyperLayout': 'maya.OpenMaya.MFnDependencyNode',
  'kHyperView': 'maya.OpenMaya.MFnDependencyNode',
  'kIkEffector': 'maya.OpenMayaAnim.MFnIkEffector',
  'kIkHandle': 'maya.OpenMayaAnim.MFnIkHandle',
  'kIkSolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kIkSystem': 'maya.OpenMaya.MFnDependencyNode',
  'kIllustratorCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kImagePlane': 'maya.OpenMaya.MFnDagNode',
  'kImageSource': 'maya.OpenMayaRender.MFnImageSource',
  'kImplicitCone': 'maya.OpenMaya.MFnDagNode',
  'kImplicitSphere': 'maya.OpenMaya.MFnDagNode',
  'kInsertKnotCrv': 'maya.OpenMaya.MFnDependencyNode',
  'kInsertKnotSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kInstancer': 'maya.OpenMayaFX.MFnInstancer',
  'kIntArrayData': 'maya.OpenMaya.MFnIntArrayData',
  'kIntersectSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kJiggleDeformer': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kJoint': 'maya.OpenMayaAnim.MFnIkJoint',
  'kJointCluster': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kKeyframeDelta': 'maya.OpenMayaAnim.MFnKeyframeDelta',
  'kKeyframeDeltaAddRemove': 'maya.OpenMayaAnim.MFnKeyframeDeltaAddRemove',
  'kKeyframeDeltaBlockAddRemove': 'maya.OpenMayaAnim.MFnKeyframeDeltaBlockAddRemove',
  'kKeyframeDeltaBreakdown': 'maya.OpenMayaAnim.MFnKeyframeDeltaBreakdown',
  'kKeyframeDeltaInfType': 'maya.OpenMayaAnim.MFnKeyframeDeltaInfType',
  'kKeyframeDeltaMove': 'maya.OpenMayaAnim.MFnKeyframeDeltaMove',
  'kKeyframeDeltaScale': 'maya.OpenMayaAnim.MFnKeyframeDeltaScale',
  'kKeyframeDeltaTangent': 'maya.OpenMayaAnim.MFnKeyframeDeltaTangent',
  'kKeyframeDeltaWeighted': 'maya.OpenMayaAnim.MFnKeyframeDeltaWeighted',
  'kKeyingGroup': 'maya.OpenMaya.MFnSet',
  'kLambert': 'maya.OpenMaya.MFnLambertShader',
  'kLattice': 'maya.OpenMayaAnim.MFnLattice',
  'kLatticeData': 'maya.OpenMaya.MFnLatticeData',
  'kLayeredShader': 'maya.OpenMaya.MFnLayeredShader',
  'kLayeredTexture': 'maya.OpenMaya.MFnDependencyNode',
  'kLeastSquares': 'maya.OpenMaya.MFnDependencyNode',
  'kLeather': 'maya.OpenMaya.MFnDependencyNode',
  'kLight': 'maya.OpenMaya.MFnLight',
  'kLightDataAttribute': 'maya.OpenMaya.MFnLightDataAttribute',
  'kLightFogMaterial': 'maya.OpenMaya.MFnDependencyNode',
  'kLightInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kLightLink': 'maya.OpenMaya.MFnDependencyNode',
  'kLightList': 'maya.OpenMaya.MFnDependencyNode',
  'kLineModifier': 'maya.OpenMaya.MFnDagNode',
  'kLocator': 'maya.OpenMaya.MFnDagNode',
  'kLodGroup': 'maya.OpenMaya.MFnTransform',
  'kLodThresholds': 'maya.OpenMaya.MFnDependencyNode',
  'kLookAt': 'maya.OpenMaya.MFnTransform',
  'kLuminance': 'maya.OpenMaya.MFnDependencyNode',
  'kMCsolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kMPbirailSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kMakeGroup': 'maya.OpenMaya.MFnDependencyNode',
  'kMandelbrot': 'maya.OpenMaya.MFnDependencyNode',
  'kMandelbrot3D': 'maya.OpenMaya.MFnDependencyNode',
  'kManipulator3D': 'maya.OpenMayaUI.MFnManip3D',
  'kMarble': 'maya.OpenMaya.MFnDependencyNode',
  'kMaterialFacade': 'maya.OpenMaya.MFnDependencyNode',
  'kMaterialInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kMatrixAdd': 'maya.OpenMaya.MFnDependencyNode',
  'kMatrixArrayData': 'maya.OpenMaya.MFnMatrixArrayData',
  'kMatrixAttribute': 'maya.OpenMaya.MFnMatrixAttribute',
  'kMatrixData': 'maya.OpenMaya.MFnMatrixData',
  'kMatrixHold': 'maya.OpenMaya.MFnDependencyNode',
  'kMatrixMult': 'maya.OpenMaya.MFnDependencyNode',
  'kMatrixPass': 'maya.OpenMaya.MFnDependencyNode',
  'kMatrixWtAdd': 'maya.OpenMaya.MFnDependencyNode',
  'kMembrane': 'maya.OpenMaya.MFnDependencyNode',
  'kMesh': 'maya.OpenMaya.MFnMesh',
  'kMeshData': 'maya.OpenMaya.MFnMeshData',
  'kMeshVarGroup': 'maya.OpenMaya.MFnTransform',
  'kMessageAttribute': 'maya.OpenMaya.MFnMessageAttribute',
  'kMidModifier': 'maya.OpenMaya.MFnDependencyNode',
  'kMotionPath': 'maya.OpenMayaAnim.MFnMotionPath',
  'kMountain': 'maya.OpenMaya.MFnDependencyNode',
  'kMoveVertexManip': 'maya.OpenMaya.MFnDependencyNode',
  'kMultDoubleLinear': 'maya.OpenMaya.MFnDependencyNode',
  'kMultilisterLight': 'maya.OpenMaya.MFnDependencyNode',
  'kMultiplyDivide': 'maya.OpenMaya.MFnDependencyNode',
  'kMute': 'maya.OpenMaya.MFnDependencyNode',
  u'kNBase': 'maya.OpenMayaFX.MFnParticleSystem',
  'kNCloth': 'maya.OpenMayaFX.MFnParticleSystem',
  'kNComponent': 'maya.OpenMaya.MFnDependencyNode',
  'kNIdData': 'maya.OpenMayaFX.MFnNIdData',
  'kNObjectData': 'maya.OpenMayaFX.MFnNObjectData',
  'kNParticle': 'maya.OpenMayaFX.MFnParticleSystem',
  'kNRigid': 'maya.OpenMayaFX.MFnParticleSystem',
  'kNearestPointOnCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kNewton': 'maya.OpenMayaFX.MFnNewtonField',
  'kNodeGraphEditorBookmarkInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kNodeGraphEditorBookmarks': 'maya.OpenMaya.MFnDependencyNode',
  'kNodeGraphEditorInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kNoise': 'maya.OpenMaya.MFnDependencyNode',
  'kNonAmbientLight': 'maya.OpenMaya.MFnNonAmbientLight',
  'kNonExtendedLight': 'maya.OpenMaya.MFnNonExtendedLight',
  'kNonLinear': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kNormalConstraint': 'maya.OpenMaya.MFnTransform',
  'kNucleus': 'maya.OpenMaya.MFnTransform',
  'kNumericAttribute': 'maya.OpenMaya.MFnNumericAttribute',
  'kNumericData': 'maya.OpenMaya.MFnNumericData',
  'kNurbsBoolean': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsCircular2PtArc': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsCircular3PtArc': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsCube': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsCurve': 'maya.OpenMaya.MFnNurbsCurve',
  'kNurbsCurveData': 'maya.OpenMaya.MFnNurbsCurveData',
  'kNurbsCurveToBezier': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsPlane': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsSquare': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsSurface': 'maya.OpenMaya.MFnNurbsSurface',
  'kNurbsSurfaceData': 'maya.OpenMaya.MFnNurbsSurfaceData',
  'kNurbsTesselate': 'maya.OpenMaya.MFnDependencyNode',
  'kNurbsToSubdiv': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectAttrFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectBinFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectMultiFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectNameFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectRenderFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectScriptFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kObjectTypeFilter': 'maya.OpenMaya.MFnDependencyNode',
  'kOcean': 'maya.OpenMaya.MFnDependencyNode',
  'kOceanShader': 'maya.OpenMaya.MFnDependencyNode',
  'kOffsetCos': 'maya.OpenMaya.MFnDependencyNode',
  'kOffsetCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kOffsetSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kOldGeometryConstraint': 'maya.OpenMaya.MFnDependencyNode',
  'kOpticalFX': 'maya.OpenMaya.MFnDependencyNode',
  'kOrientConstraint': 'maya.OpenMaya.MFnTransform',
  'kOrientationMarker': 'maya.OpenMaya.MFnDagNode',
  u'kOrthoGrid': 'maya.OpenMaya.MFnDagNode',
  'kPASolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kPairBlend': 'maya.OpenMaya.MFnDependencyNode',
  'kParamDimension': 'maya.OpenMaya.MFnDagNode',
  'kParentConstraint': 'maya.OpenMaya.MFnTransform',
  'kParticle': 'maya.OpenMayaFX.MFnParticleSystem',
  'kParticleAgeMapper': 'maya.OpenMaya.MFnDependencyNode',
  'kParticleCloud': 'maya.OpenMaya.MFnDependencyNode',
  'kParticleColorMapper': 'maya.OpenMaya.MFnDependencyNode',
  'kParticleIncandecenceMapper': 'maya.OpenMaya.MFnDependencyNode',
  'kParticleSamplerInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kParticleTransparencyMapper': 'maya.OpenMaya.MFnDependencyNode',
  'kPartition': 'maya.OpenMaya.MFnPartition',
  'kPassContributionMap': 'maya.OpenMaya.MFnDependencyNode',
  'kPfxGeometry': 'maya.OpenMayaFX.MFnPfxGeometry',
  'kPfxHair': 'maya.OpenMayaFX.MFnPfxGeometry',
  'kPfxToon': 'maya.OpenMayaFX.MFnPfxGeometry',
  'kPhong': 'maya.OpenMaya.MFnPhongShader',
  'kPhongExplorer': 'maya.OpenMaya.MFnPhongEShader',
  'kPlace2dTexture': 'maya.OpenMaya.MFnDependencyNode',
  'kPlace3dTexture': 'maya.OpenMaya.MFnTransform',
  'kPlanarTrimSrf': 'maya.OpenMaya.MFnDependencyNode',
  u'kPlane': 'maya.OpenMaya.MFnDagNode',
  'kPlugin': 'maya.OpenMayaMPx.MFnPlugin',
  'kPluginBlendShape': 'maya.OpenMayaAnim.MFnBlendShapeDeformer',
  'kPluginCameraSet': 'maya.OpenMaya.MFnCameraSet',
  'kPluginClientDevice': 'maya.OpenMaya.MFnDependencyNode',
  'kPluginConstraintNode': 'maya.OpenMaya.MFnTransform',
  'kPluginData': 'maya.OpenMaya.MFnPluginData',
  'kPluginDeformerNode': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kPluginDependNode': 'maya.OpenMaya.MFnDependencyNode',
  'kPluginEmitterNode': 'maya.OpenMaya.MFnTransform',
  'kPluginFieldNode': 'maya.OpenMayaFX.MFnField',
  'kPluginGeometryFilter': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kPluginHardwareShader': 'maya.OpenMaya.MFnDependencyNode',
  'kPluginHwShaderNode': 'maya.OpenMaya.MFnDependencyNode',
  'kPluginIkSolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kPluginImagePlaneNode': 'maya.OpenMaya.MFnDagNode',
  'kPluginLocatorNode': 'maya.OpenMaya.MFnDagNode',
  'kPluginManipContainer': 'maya.OpenMaya.MFnDependencyNode',
  'kPluginManipulatorNode': 'maya.OpenMaya.MFnDependencyNode',
  'kPluginMotionPathNode': 'maya.OpenMayaAnim.MFnMotionPath',
  'kPluginObjectSet': 'maya.OpenMaya.MFnSet',
  'kPluginParticleAttributeMapperNode': 'maya.OpenMaya.MFnDependencyNode',
  'kPluginShape': 'maya.OpenMaya.MFnDagNode',
  'kPluginSkinCluster': 'maya.OpenMayaAnim.MFnSkinCluster',
  'kPluginSpringNode': 'maya.OpenMaya.MFnDagNode',
  'kPluginTransformNode': 'maya.OpenMaya.MFnTransform',
  'kPlusMinusAverage': 'maya.OpenMaya.MFnDependencyNode',
  'kPointArrayData': 'maya.OpenMaya.MFnPointArrayData',
  'kPointConstraint': 'maya.OpenMaya.MFnTransform',
  'kPointLight': 'maya.OpenMaya.MFnPointLight',
  'kPointMatrixMult': 'maya.OpenMaya.MFnDependencyNode',
  'kPointOnCurveInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kPointOnCurveManip': 'maya.OpenMayaUI.MFnPointOnCurveManip',
  'kPointOnPolyConstraint': 'maya.OpenMaya.MFnTransform',
  'kPointOnSurfaceInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kPointOnSurfaceManip': 'maya.OpenMayaUI.MFnPointOnSurfaceManip',
  'kPoleVectorConstraint': 'maya.OpenMaya.MFnTransform',
  'kPolyAppend': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyAppendVertex': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyAutoProj': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyAverageVertex': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyBevel': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyBevel2': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyBevel3': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyBlindData': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyBoolOp': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyBridgeEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCBoolOp': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyChipOff': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCircularize': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyClean': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCloseBorder': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCollapseEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCollapseF': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyColorDel': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyColorMod': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyColorPerVertex': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCone': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyConnectComponents': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyContourProj': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCreaseEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCreateFacet': 'maya.OpenMaya.MFnDependencyNode',
  u'kPolyCreator': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCube': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCut': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCylProj': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyCylinder': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyDelEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyDelFacet': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyDelVertex': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyDuplicateEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyEdgeToCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyEditEdgeFlow': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyExtrudeEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyExtrudeFacet': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyExtrudeVertex': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyFlipEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyFlipUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyHelix': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyHoleFace': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyLayoutUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMapCut': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMapDel': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMapSew': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMapSewMove': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMergeEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMergeFacet': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMergeUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMergeVert': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMesh': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMirror': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMoveEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMoveFacet': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMoveFacetUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMoveUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyMoveVertex': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyNormal': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyNormalPerVertex': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyNormalizeUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPassThru': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPinUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPipe': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPlanProj': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPlatonicSolid': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPoke': 'maya.OpenMaya.MFnDependencyNode',
  u'kPolyPrimitive': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPrimitiveMisc': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPrism': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyProj': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyProjectCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyPyramid': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyQuad': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyReduce': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyRemesh': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySeparate': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySewEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySmooth': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySmoothFacet': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySmoothProxy': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySoftEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySphProj': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySphere': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySpinEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySplit': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySplitEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySplitRing': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySplitVert': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyStraightenUVBorder': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySubdEdge': 'maya.OpenMaya.MFnDependencyNode',
  'kPolySubdFacet': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyToSubdiv': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyTorus': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyTransfer': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyTriangulate': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyTweak': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyTweakUV': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyUVRectangle': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyUnite': 'maya.OpenMaya.MFnDependencyNode',
  'kPolyWedgeFace': 'maya.OpenMaya.MFnDependencyNode',
  'kPoseInterpolatorManager': 'maya.OpenMaya.MFnDependencyNode',
  'kPositionMarker': 'maya.OpenMaya.MFnDagNode',
  'kPostProcessList': 'maya.OpenMaya.MFnDependencyNode',
  'kPrecompExport': 'maya.OpenMaya.MFnDependencyNode',
  u'kPrimitive': 'maya.OpenMaya.MFnDependencyNode',
  'kProjectCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kProjectTangent': 'maya.OpenMaya.MFnDependencyNode',
  'kProjection': 'maya.OpenMaya.MFnDependencyNode',
  'kProxWrap': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kProxyManager': 'maya.OpenMaya.MFnDependencyNode',
  'kPsdFileTexture': 'maya.OpenMaya.MFnDependencyNode',
  'kQuadShadingSwitch': 'maya.OpenMaya.MFnDependencyNode',
  'kRBFsurface': 'maya.OpenMaya.MFnDependencyNode',
  'kRPsolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kRadial': 'maya.OpenMayaFX.MFnRadialField',
  'kRamp': 'maya.OpenMaya.MFnDependencyNode',
  'kRampShader': 'maya.OpenMaya.MFnDependencyNode',
  'kReForm': 'maya.OpenMaya.MFnDependencyNode',
  'kRebuildCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kRebuildSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kRecord': 'maya.OpenMaya.MFnDependencyNode',
  'kReference': 'maya.OpenMaya.MFnReference',
  'kReflect': 'maya.OpenMaya.MFnReflectShader',
  'kRemapColor': 'maya.OpenMaya.MFnDependencyNode',
  'kRemapHsv': 'maya.OpenMaya.MFnDependencyNode',
  'kRemapValue': 'maya.OpenMaya.MFnDependencyNode',
  'kRenderBox': 'maya.OpenMaya.MFnDagNode',
  'kRenderCone': 'maya.OpenMaya.MFnDagNode',
  'kRenderGlobals': 'maya.OpenMaya.MFnDependencyNode',
  'kRenderGlobalsList': 'maya.OpenMaya.MFnDependencyNode',
  'kRenderLayer': 'maya.OpenMayaRender.MFnRenderLayer',
  'kRenderLayerManager': 'maya.OpenMaya.MFnDependencyNode',
  'kRenderPass': 'maya.OpenMayaRender.MFnRenderPass',
  'kRenderPassSet': 'maya.OpenMaya.MFnDependencyNode',
  'kRenderQuality': 'maya.OpenMaya.MFnDependencyNode',
  'kRenderRect': 'maya.OpenMaya.MFnDagNode',
  'kRenderSphere': 'maya.OpenMaya.MFnDagNode',
  'kRenderTarget': 'maya.OpenMayaRender.MFnImageSource',
  'kRenderUtilityList': 'maya.OpenMaya.MFnDependencyNode',
  'kRenderedImageSource': 'maya.OpenMayaRender.MFnImageSource',
  'kRenderingList': 'maya.OpenMaya.MFnDependencyNode',
  'kReorderUVSet': 'maya.OpenMaya.MFnDependencyNode',
  'kResolution': 'maya.OpenMaya.MFnDependencyNode',
  u'kResultCurve': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kResultCurveTimeToAngular': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kResultCurveTimeToDistance': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kResultCurveTimeToTime': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kResultCurveTimeToUnitless': 'maya.OpenMayaAnim.MFnAnimCurve',
  'kReverse': 'maya.OpenMaya.MFnDependencyNode',
  'kReverseCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kReverseSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kRevolve': 'maya.OpenMaya.MFnDependencyNode',
  u'kRevolvedPrimitive': 'maya.OpenMaya.MFnDependencyNode',
  'kRgbToHsv': 'maya.OpenMaya.MFnDependencyNode',
  'kRigid': 'maya.OpenMaya.MFnDagNode',
  'kRigidConstraint': 'maya.OpenMaya.MFnTransform',
  'kRigidSolver': 'maya.OpenMaya.MFnDependencyNode',
  'kRock': 'maya.OpenMaya.MFnDependencyNode',
  'kRotateManip': 'maya.OpenMayaUI.MFnRotateManip',
  'kRoundConstantRadius': 'maya.OpenMaya.MFnDependencyNode',
  'kSCsolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kSPbirailSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kSamplerInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kScaleConstraint': 'maya.OpenMaya.MFnTransform',
  'kScaleManip': 'maya.OpenMayaUI.MFnScaleManip',
  'kScript': 'maya.OpenMaya.MFnDependencyNode',
  'kSculpt': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kSelectionListOperator': 'maya.OpenMaya.MFnDependencyNode',
  'kSequenceManager': 'maya.OpenMaya.MFnDependencyNode',
  'kSequencer': 'maya.OpenMaya.MFnDependencyNode',
  'kSet': 'maya.OpenMaya.MFnSet',
  'kSetRange': 'maya.OpenMaya.MFnDependencyNode',
  'kShaderGlow': 'maya.OpenMaya.MFnDependencyNode',
  'kShaderList': 'maya.OpenMaya.MFnDependencyNode',
  'kShadingEngine': 'maya.OpenMaya.MFnSet',
  'kShadingMap': 'maya.OpenMaya.MFnDependencyNode',
  u'kShape': 'maya.OpenMaya.MFnDagNode',
  'kShapeEditorManager': 'maya.OpenMaya.MFnDependencyNode',
  'kShot': 'maya.OpenMaya.MFnDependencyNode',
  'kShrinkWrapFilter': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kSimpleVolumeShader': 'maya.OpenMaya.MFnDependencyNode',
  'kSingleIndexedComponent': 'maya.OpenMaya.MFnSingleIndexedComponent',
  'kSingleShadingSwitch': 'maya.OpenMaya.MFnDependencyNode',
  'kSketchPlane': 'maya.OpenMaya.MFnDagNode',
  'kSkin': 'maya.OpenMaya.MFnDependencyNode',
  'kSkinBinding': 'maya.OpenMaya.MFnDependencyNode',
  'kSkinClusterFilter': 'maya.OpenMayaAnim.MFnSkinCluster',
  'kSmear': 'maya.OpenMaya.MFnDependencyNode',
  'kSmoothCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kSmoothTangentSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kSnapshot': 'maya.OpenMaya.MFnDagNode',
  'kSnapshotPath': 'maya.OpenMaya.MFnDependencyNode',
  'kSnow': 'maya.OpenMaya.MFnDependencyNode',
  'kSoftMod': 'maya.OpenMaya.MFnDagNode',
  'kSoftModFilter': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kSolidFractal': 'maya.OpenMaya.MFnDependencyNode',
  'kSphere': 'maya.OpenMaya.MFnDependencyNode',
  'kSphereData': 'maya.OpenMaya.MFnSphereData',
  'kSplineSolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kSpotLight': 'maya.OpenMaya.MFnSpotLight',
  'kSpring': 'maya.OpenMaya.MFnDagNode',
  'kSquareSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kStateManip': 'maya.OpenMayaUI.MFnStateManip',
  'kStencil': 'maya.OpenMaya.MFnDependencyNode',
  'kStereoCameraMaster': 'maya.OpenMaya.MFnCamera',
  'kStitchAsNurbsShell': 'maya.OpenMaya.MFnDependencyNode',
  'kStitchSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kStringArrayData': 'maya.OpenMaya.MFnStringArrayData',
  'kStringData': 'maya.OpenMaya.MFnStringData',
  'kStroke': 'maya.OpenMayaFX.MFnPfxGeometry',
  'kStrokeGlobals': 'maya.OpenMaya.MFnDependencyNode',
  'kStucco': 'maya.OpenMaya.MFnDependencyNode',
  'kStudioClearCoat': 'maya.OpenMaya.MFnDependencyNode',
  'kStyleCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kSubCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kSubSurface': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdAddTopology': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdAutoProj': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdBlindData': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdCleanTopology': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdHierBlind': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdLayoutUV': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdMapCut': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdMapSewMove': 'maya.OpenMaya.MFnDependencyNode',
  u'kSubdModifier': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdPlanProj': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdTweak': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdTweakUV': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdiv': 'maya.OpenMaya.MFnSubd',
  'kSubdivCollapse': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdivCompId': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdivData': 'maya.OpenMaya.MFnSubdData',
  'kSubdivReverseFaces': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdivToNurbs': 'maya.OpenMaya.MFnDependencyNode',
  'kSubdivToPoly': 'maya.OpenMaya.MFnDependencyNode',
  'kSurface': 'maya.OpenMaya.MFnDagNode',
  'kSurfaceInfo': 'maya.OpenMaya.MFnDependencyNode',
  'kSurfaceLuminance': 'maya.OpenMaya.MFnDependencyNode',
  'kSurfaceShader': 'maya.OpenMaya.MFnDependencyNode',
  'kSurfaceVarGroup': 'maya.OpenMaya.MFnTransform',
  'kSymmetryConstraint': 'maya.OpenMaya.MFnTransform',
  'kTangentConstraint': 'maya.OpenMaya.MFnTransform',
  'kTension': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kTexLattice': 'maya.OpenMaya.MFnDependencyNode',
  'kTextCurves': 'maya.OpenMaya.MFnDependencyNode',
  u'kTexture2d': 'maya.OpenMaya.MFnDependencyNode',
  u'kTexture3d': 'maya.OpenMaya.MFnDependencyNode',
  'kTextureBakeSet': 'maya.OpenMaya.MFnSet',
  'kTextureDeformer': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kTextureDeformerHandle': 'maya.OpenMaya.MFnTransform',
  u'kTextureEnv': 'maya.OpenMaya.MFnDependencyNode',
  'kTextureList': 'maya.OpenMaya.MFnDependencyNode',
  u'kThreadedDevice': 'maya.OpenMaya.MFnDependencyNode',
  'kTime': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeEditor': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeEditorAnimSource': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeEditorClip': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeEditorClipBase': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeEditorClipEvaluator': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeEditorInterpolator': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeEditorTracks': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeFunction': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeToUnitConversion': 'maya.OpenMaya.MFnDependencyNode',
  'kTimeWarp': 'maya.OpenMaya.MFnDependencyNode',
  'kToggleManip': 'maya.OpenMayaUI.MFnToggleManip',
  'kToolContext': 'maya.OpenMayaUI.MFnToolContext',
  'kToonLineAttributes': 'maya.OpenMaya.MFnDependencyNode',
  'kTorus': 'maya.OpenMaya.MFnDependencyNode',
  'kTrackInfoManager': 'maya.OpenMaya.MFnDependencyNode',
  'kTransferAttributes': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kTransform': 'maya.OpenMaya.MFnTransform',
  'kTransformGeometry': 'maya.OpenMaya.MFnDependencyNode',
  'kTrim': 'maya.OpenMaya.MFnDependencyNode',
  'kTrimWithBoundaries': 'maya.OpenMaya.MFnDependencyNode',
  'kTripleIndexedComponent': 'maya.OpenMaya.MFnTripleIndexedComponent',
  'kTripleShadingSwitch': 'maya.OpenMaya.MFnDependencyNode',
  'kTurbulence': 'maya.OpenMayaFX.MFnTurbulenceField',
  'kTweak': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kTypedAttribute': 'maya.OpenMaya.MFnTypedAttribute',
  'kUInt64ArrayData': 'maya.OpenMaya.MFnUInt64ArrayData',
  'kUint64SingleIndexedComponent': 'maya.OpenMaya.MFnUint64SingleIndexedComponent',
  'kUniform': 'maya.OpenMayaFX.MFnUniformField',
  'kUnitAttribute': 'maya.OpenMaya.MFnUnitAttribute',
  'kUnitConversion': 'maya.OpenMaya.MFnDependencyNode',
  'kUnitToTimeConversion': 'maya.OpenMaya.MFnDependencyNode',
  'kUnknown': 'maya.OpenMaya.MFnDependencyNode',
  'kUnknownDag': 'maya.OpenMaya.MFnDagNode',
  'kUnknownTransform': 'maya.OpenMaya.MFnTransform',
  'kUntrim': 'maya.OpenMaya.MFnDependencyNode',
  'kUseBackground': 'maya.OpenMaya.MFnDependencyNode',
  'kUvChooser': 'maya.OpenMaya.MFnDependencyNode',
  'kVectorArrayData': 'maya.OpenMaya.MFnVectorArrayData',
  'kVectorProduct': 'maya.OpenMaya.MFnDependencyNode',
  'kVertexBakeSet': 'maya.OpenMaya.MFnSet',
  'kViewColorManager': 'maya.OpenMaya.MFnDependencyNode',
  'kVolumeAxis': 'maya.OpenMayaFX.MFnVolumeAxisField',
  'kVolumeFog': 'maya.OpenMaya.MFnDependencyNode',
  'kVolumeLight': 'maya.OpenMaya.MFnVolumeLight',
  'kVolumeNoise': 'maya.OpenMaya.MFnDependencyNode',
  'kVolumeShader': 'maya.OpenMaya.MFnDependencyNode',
  'kVortex': 'maya.OpenMayaFX.MFnVortexField',
  'kWater': 'maya.OpenMaya.MFnDependencyNode',
  'kWeightGeometryFilt': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kWire': 'maya.OpenMayaAnim.MFnWireDeformer',
  'kWood': 'maya.OpenMaya.MFnDependencyNode',
  'kWrapFilter': 'maya.OpenMayaAnim.MFnGeometryFilter',
  'kXformManip': 'maya.OpenMaya.MFnDependencyNode'},
 {'M3dView': {'enums': {'ColorTable': {'valueDocs': {'activeColors': 'Colors for active objects.',
                                                     'backgroundColor': 'Colors for background color.',
                                                     'dormantColors': 'Colors for dormant objects.',
                                                     'kActiveColors': 'Colors for active objects.',
                                                     'kBackgroundColor': 'Colors for background color.',
                                                     'kDormantColors': 'Colors for dormant objects.',
                                                     'kTemplateColor': 'Colors for templated objects.',
                                                     'templateColor': 'Colors for templated objects.'},
                                       'values': "Enum('ColorTable', {'kActiveColors': 0, 'kDormantColors': 2, 'kTemplateColor': 5, 'kBackgroundColor': 6})"},
                        'DepthBufferFormat': {'valueDocs': {'float': 'Floating point.',
                                                            'k8': '8 bits.',
                                                            'kDepth_8': '8 bits.',
                                                            'kDepth_Float': 'Floating point.'},
                                              'values': "Enum('DepthBufferFormat', {'kDepth_8': 0, 'kDepth_Float': 1})"},
                        'DisplayObjects': {'valueDocs': {'displayCVs': 'Show NURBS CVs.',
                                                         'displayCameras': 'Show camera.',
                                                         'displayDeformers': 'Show deformers.',
                                                         'displayDimensions': 'Show dimensions.',
                                                         'displayDynamicConstraints': 'Show nDynamicConstraints.',
                                                         'displayDynamics': 'Show dynamics.',
                                                         'displayEverything': 'Show everything.',
                                                         'displayFluids': 'Show fluids.',
                                                         'displayFollicles': 'Show follcles.',
                                                         'displayGrid': 'Show the grid.',
                                                         'displayHairSystems': 'Show hair systems.',
                                                         'displayHulls': 'Show NURBS hulls.',
                                                         'displayIkHandles': 'Show IK handles.',
                                                         'displayImagePlane': 'Show image plane.',
                                                         'displayJoints': 'Show joints.',
                                                         'displayLights': 'Show lights.',
                                                         'displayLocators': 'Show locators.',
                                                         'displayManipulators': 'Show Manipulators.',
                                                         'displayMeshes': 'Show meshes.',
                                                         'displayNCloths': 'Show nCloths.',
                                                         'displayNParticles': 'Show nParticles.',
                                                         'displayNRigids': 'Show nRigids.',
                                                         'displayNurbsCurves': 'Show nurbs curves.',
                                                         'displayNurbsSurfaces': 'Show nurbs surfaces.',
                                                         'displayParticleInstancers': 'Show particle instancers.',
                                                         'displayPivots': 'Show pivots.',
                                                         'displayPlanes': 'Show planes.',
                                                         'displaySelectHandles': 'Show selection handles.',
                                                         'displayStrokes': 'Show strokes.',
                                                         'displaySubdivSurfaces': 'Show subdivision surfaces.',
                                                         'displayTextures': 'Show textures.',
                                                         'excludeMotionTrails': 'Show motion trails.',
                                                         'excludePluginShapes': 'Show plugin shapes.',
                                                         'kDisplayCVs': 'Show NURBS CVs.',
                                                         'kDisplayCameras': 'Show camera.',
                                                         'kDisplayDeformers': 'Show deformers.',
                                                         'kDisplayDimensions': 'Show dimensions.',
                                                         'kDisplayDynamicConstraints': 'Show nDynamicConstraints.',
                                                         'kDisplayDynamics': 'Show dynamics.',
                                                         'kDisplayEverything': 'Show everything.',
                                                         'kDisplayFluids': 'Show fluids.',
                                                         'kDisplayFollicles': 'Show follcles.',
                                                         'kDisplayGrid': 'Show the grid.',
                                                         'kDisplayHairSystems': 'Show hair systems.',
                                                         'kDisplayHulls': 'Show NURBS hulls.',
                                                         'kDisplayIkHandles': 'Show IK handles.',
                                                         'kDisplayImagePlane': 'Show image plane.',
                                                         'kDisplayJoints': 'Show joints.',
                                                         'kDisplayLights': 'Show lights.',
                                                         'kDisplayLocators': 'Show locators.',
                                                         'kDisplayManipulators': 'Show Manipulators.',
                                                         'kDisplayMeshes': 'Show meshes.',
                                                         'kDisplayNCloths': 'Show nCloths.',
                                                         'kDisplayNParticles': 'Show nParticles.',
                                                         'kDisplayNRigids': 'Show nRigids.',
                                                         'kDisplayNurbsCurves': 'Show nurbs curves.',
                                                         'kDisplayNurbsSurfaces': 'Show nurbs surfaces.',
                                                         'kDisplayParticleInstancers': 'Show particle instancers.',
                                                         'kDisplayPivots': 'Show pivots.',
                                                         'kDisplayPlanes': 'Show planes.',
                                                         'kDisplaySelectHandles': 'Show selection handles.',
                                                         'kDisplayStrokes': 'Show strokes.',
                                                         'kDisplaySubdivSurfaces': 'Show subdivision surfaces.',
                                                         'kDisplayTextures': 'Show textures.',
                                                         'kExcludeMotionTrails': 'Show motion trails.',
                                                         'kExcludePluginShapes': 'Show plugin shapes.'},
                                           'values': "Enum('DisplayObjects', {'kExcludePluginShapes': -2147483648, 'kDisplayEverything': -1, 'kDisplayNurbsCurves': 1, 'kDisplayNurbsSurfaces': 2, 'kDisplayMeshes': 4, 'kDisplayPlanes': 8, 'kDisplayLights': 16, 'kDisplayCameras': 32, 'kDisplayJoints': 64, 'kDisplayIkHandles': 128, 'kDisplayDeformers': 256, 'kDisplayDynamics': 512, 'kDisplayParticleInstancers': 1024, 'kDisplayLocators': 2048, 'kDisplayDimensions': 4096, 'kDisplaySelectHandles': 8192, 'kDisplayPivots': 16384, 'kDisplayTextures': 32768, 'kDisplayGrid': 65536, 'kDisplayCVs': 131072, 'kDisplayHulls': 262144, 'kDisplayStrokes': 524288, 'kDisplaySubdivSurfaces': 1048576, 'kDisplayFluids': 2097152, 'kDisplayFollicles': 4194304, 'kDisplayHairSystems': 8388608, 'kDisplayImagePlane': 16777216, 'kDisplayNCloths': 33554432, 'kDisplayNRigids': 67108864, 'kDisplayDynamicConstraints': 134217728, 'kDisplayManipulators': 268435456, 'kDisplayNParticles': 536870912, 'kExcludeMotionTrails': 1073741824})"},
                        'DisplayStatus': {'valueDocs': {'active': 'Object is active (selected).',
                                                        'activeAffected': 'Affected by active object(s).',
                                                        'activeComponent': 'Object has active components.',
                                                        'activeTemplate': 'Object is active and templated.',
                                                        'dormant': 'Object is dormant (not selected, no other drawing mode enabled).',
                                                        'hilite': 'Object is hilited (has selectable components).',
                                                        'intermediateObject': 'Construction object (not drawn).',
                                                        'invisible': 'Object is invisible (not drawn).',
                                                        'kActive': 'Object is active (selected).',
                                                        'kActiveAffected': 'Affected by active object(s).',
                                                        'kActiveComponent': 'Object has active components.',
                                                        'kActiveTemplate': 'Object is active and templated.',
                                                        'kDormant': 'Object is dormant (not selected, no other drawing mode enabled).',
                                                        'kHilite': 'Object is hilited (has selectable components).',
                                                        'kIntermediateObject': 'Construction object (not drawn).',
                                                        'kInvisible': 'Object is invisible (not drawn).',
                                                        'kLead': 'Last selected object.',
                                                        'kLive': 'Object is live (construction surface).',
                                                        'kNoStatus': 'Object does not have a valid display status.',
                                                        'kTemplate': 'Object is templated (Not renderable).',
                                                        'lead': 'Last selected object.',
                                                        'live': 'Object is live (construction surface).',
                                                        'noStatus': 'Object does not have a valid display status.',
                                                        'template': 'Object is templated (Not renderable).'},
                                          'values': "Enum('DisplayStatus', {'kActive': 0, 'kLive': 1, 'kDormant': 2, 'kInvisible': 3, 'kHilite': 4, 'kTemplate': 5, 'kActiveTemplate': 6, 'kActiveComponent': 7, 'kLead': 8, 'kIntermediateObject': 9, 'kActiveAffected': 10, 'kNoStatus': 11})"},
                        'DisplayStyle': {'valueDocs': {'boundingBox': 'Bounding box display.',
                                                       'flatShaded': 'Flat shaded display.',
                                                       'gouraudShaded': 'Gouraud shaded display.',
                                                       'kBoundingBox': 'Bounding box display.',
                                                       'kFlatShaded': 'Flat shaded display.',
                                                       'kGouraudShaded': 'Gouraud shaded display.',
                                                       'kPoints': 'Points only display.',
                                                       'kWireFrame': 'Wire frame display.',
                                                       'points': 'Points only display.',
                                                       'wireFrame': 'Wire frame display.'},
                                         'values': "Enum('DisplayStyle', {'kBoundingBox': 0, 'kFlatShaded': 1, 'kGouraudShaded': 2, 'kWireFrame': 3, 'kPoints': 4})"},
                        'LightingMode': {'valueDocs': {'kLightActive': 'Active lights.',
                                                       'kLightAll': 'All lights.',
                                                       'kLightDefault': 'Default light.',
                                                       'kLightNone': 'No lights / lighting disabled.',
                                                       'kLightSelected': 'Selected lights.',
                                                       'kUnused1': 'Not currently used in Maya.',
                                                       'lightActive': 'Active lights.',
                                                       'lightAll': 'All lights.',
                                                       'lightDefault': 'Default light.',
                                                       'lightNone': 'No lights / lighting disabled.',
                                                       'lightSelected': 'Selected lights.',
                                                       'unused1': 'Not currently used in Maya.'},
                                         'values': "Enum('LightingMode', {'kLightAll': 0, 'kLightSelected': 1, 'kLightActive': 2, 'kLightDefault': 3, 'kUnused1': 4, 'kLightNone': 5})"},
                        'LineStipplePattern': {'valueDocs': {'dashed': 'Dashed line stipple.',
                                                             'kStippleDashed': 'Dashed line stipple.',
                                                             'kStippleNone': 'No stipple. Solid line.',
                                                             'none': 'No stipple. Solid line.'},
                                               'values': "Enum('LineStipplePattern', {'kStippleNone': 0, 'kStippleDashed': 1})"},
                        'RendererName': {'valueDocs': {'defaultQualityRenderer': 'Equivalent to when the renderer name is "base_OpenGL_Renderer" when queried from the "modelEditor" command.',
                                                       'externalRenderer': 'An externally defined renderer name has been set.',
                                                       'highQualityRenderer': 'Equivalent to when the renderer name is "hwRender_OpenGL_Renderer" when queried from the "modelEditor" command.',
                                                       'kDefaultQualityRenderer': 'Equivalent to when the renderer name is "base_OpenGL_Renderer" when queried from the "modelEditor" command.',
                                                       'kExternalRenderer': 'An externally defined renderer name has been set.',
                                                       'kHighQualityRenderer': 'Equivalent to when the renderer name is "hwRender_OpenGL_Renderer" when queried from the "modelEditor" command.',
                                                       'kViewport2Renderer': 'Equivalent to the viewport 2.0 renderer.',
                                                       'viewport2Renderer': 'Equivalent to the viewport 2.0 renderer.'},
                                         'values': "Enum('RendererName', {'kDefaultQualityRenderer': 0, 'kHighQualityRenderer': 1, 'kViewport2Renderer': 2, 'kExternalRenderer': 3})"},
                        'TextPosition': {'valueDocs': {'center': 'Draw text centered around the point.',
                                                       'kCenter': 'Draw text centered around the point.',
                                                       'kLeft': 'Draw text to the left of the point.',
                                                       'kRight': 'Draw text to the right of the point.',
                                                       'left': 'Draw text to the left of the point.',
                                                       'right': 'Draw text to the right of the point.'},
                                         'values': "Enum('TextPosition', {'kLeft': 0, 'kCenter': 1, 'kRight': 2})"}},
              'invertibles': [('setMultipleDrawPassCount',
                               'multipleDrawPassCount'),
                              ('setShowObjectFilterNameInHUD',
                               'showObjectFilterNameInHUD'),
                              ('setObjectListFilterName',
                               'objectListFilterName'),
                              ('setViewSelectedPrefix',
                               'viewSelectedPrefix'),
                              ('setDisallowPolygonOffset',
                               'disallowPolygonOffset'),
                              ('setColorMask', 'colorMask'),
                              ('setObjectDisplay', 'objectDisplay'),
                              ('setShowViewSelectedChildren',
                               'showViewSelectedChildren'),
                              ('setPluginObjectDisplay',
                               'pluginObjectDisplay'),
                              ('setRenderOverrideName',
                               'renderOverrideName'),
                              ('setCamera', 'getCamera'),
                              ('setDisplayStyle', 'displayStyle')],
              'methods': {'active3dView': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the active view in the form of a class ( M3dView ) that can operate on it.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Active view class.',
                                                           'qualifiers': [],
                                                           'type': 'M3dView'},
                                            'returnType': 'M3dView',
                                            'static': True,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                          'activeAffectedColor': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the color for active affected objects.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The active affected color',
                                                                  'qualifiers': [],
                                                                  'type': 'MColor'},
                                                   'returnType': 'MColor',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                          'activeTemplateColor': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the color for active template objects.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The active template color',
                                                                  'qualifiers': [],
                                                                  'type': 'MColor'},
                                                   'returnType': 'MColor',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                          'applicationShell': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nReturns the native handle for Maya's main window.",
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The window handle.',
                                                               'qualifiers': [],
                                                               'type': ('M3dView',
                                                                        'MNativeWindowHdl')},
                                                'returnType': ('M3dView',
                                                               'MNativeWindowHdl'),
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                          'backgroundColor': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the value of the background color.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The background color',
                                                              'qualifiers': [],
                                                              'type': 'MColor'},
                                               'returnType': 'MColor',
                                               'static': True,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'backgroundColorBottom': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the value of the background gradient bottom color.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The background gradient bottom color',
                                                                    'qualifiers': [],
                                                                    'type': 'MColor'},
                                                     'returnType': 'MColor',
                                                     'static': True,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                          'backgroundColorTop': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the value of the background gradient top color.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The background gradient top color',
                                                                 'qualifiers': [],
                                                                 'type': 'MColor'},
                                                  'returnType': 'MColor',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                          'beginGL': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': True,
                                       'doc': '\n This method is obsolete. \n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                          'beginProjMatrixOverride': [{'argInfo': {'projectionMatrix': {'doc': 'Projection matrix used in openGL drawing',
                                                                                        'type': 'MMatrix'}},
                                                       'args': [('projectionMatrix',
                                                                 'MMatrix',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': True,
                                                       'doc': '\n This method is obsolete. \n',
                                                       'inArgs': ['projectionMatrix'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'projectionMatrix': ['&']},
                                                       'types': {'projectionMatrix': 'MMatrix'}}],
                          'beginSelect': [{'argInfo': {'buffer': {'doc': 'OpenGl pick buffer ',
                                                                  'type': ('M3dView',
                                                                           'GLuint')},
                                                       'size': {'doc': 'Buffer size (number of GLint) ',
                                                                'type': ('M3dView',
                                                                         'GLsizei')}},
                                           'args': [('buffer',
                                                     ('M3dView',
                                                      'GLuint'),
                                                     'in'),
                                                    ('size',
                                                     ('M3dView',
                                                      'GLsizei'),
                                                     'in')],
                                           'defaults': {'buffer': None,
                                                        'size': ('M3dView',
                                                                 'GLsizei',
                                                                 '0')},
                                           'deprecated': False,
                                           'doc': '\r\nStart selecting. The buffer passed is used to record selection hits. A selection hit consists of the following 4 items:',
                                           'inArgs': ['buffer', 'size'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'buffer': ['*'],
                                                              'size': []},
                                           'types': {'buffer': ('M3dView',
                                                                'GLuint'),
                                                     'size': ('M3dView',
                                                              'GLsizei')}}],
                          'beginXorDrawing': [{'argInfo': {'disableDepthTesting': {'doc': 'Disable depth testing during draw. Default is true. ',
                                                                                   'type': 'bool'},
                                                           'drawOrthographic': {'doc': 'Draw using orthographic projection. Default is true. ',
                                                                                'type': 'bool'},
                                                           'lineColor': {'doc': 'Line color. Default is white (1,1,1).',
                                                                         'type': 'MColor'},
                                                           'lineWidth': {'doc': 'Set up line width. Default is 1. ',
                                                                         'type': 'float'},
                                                           'stipplePattern': {'doc': 'Line stipple pattern. Default is kStippleNone. ',
                                                                              'type': ('M3dView',
                                                                                       'LineStipplePattern')}},
                                               'args': [('drawOrthographic',
                                                         'bool',
                                                         'in'),
                                                        ('disableDepthTesting',
                                                         'bool',
                                                         'in'),
                                                        ('lineWidth',
                                                         'float',
                                                         'in'),
                                                        ('stipplePattern',
                                                         ('M3dView',
                                                          'LineStipplePattern'),
                                                         'in'),
                                                        ('lineColor',
                                                         'MColor',
                                                         'in')],
                                               'defaults': {'disableDepthTesting': True,
                                                            'drawOrthographic': True,
                                                            'lineColor': 'MColor(1,1,1)',
                                                            'lineWidth': '1.0f',
                                                            'stipplePattern': ('M3dView',
                                                                               'LineStipplePattern',
                                                                               'kStippleNone')},
                                               'deprecated': False,
                                               'doc': '\r\nSetup the context for exclusive-or (XOR) drawing.',
                                               'inArgs': ['drawOrthographic',
                                                          'disableDepthTesting',
                                                          'lineWidth',
                                                          'stipplePattern',
                                                          'lineColor'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'disableDepthTesting': [],
                                                                  'drawOrthographic': [],
                                                                  'lineColor': ['const',
                                                                                '&'],
                                                                  'lineWidth': [],
                                                                  'stipplePattern': []},
                                               'types': {'disableDepthTesting': 'bool',
                                                         'drawOrthographic': 'bool',
                                                         'lineColor': 'MColor',
                                                         'lineWidth': 'float',
                                                         'stipplePattern': ('M3dView',
                                                                            'LineStipplePattern')}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'colorAtIndex': [{'argInfo': {'index': {'doc': 'Index of the color to retrieve ',
                                                                  'type': 'uint'},
                                                        'table': {'doc': 'Table to index into ',
                                                                  'type': ('M3dView',
                                                                           'ColorTable')}},
                                            'args': [('index',
                                                      'uint',
                                                      'in'),
                                                     ('table',
                                                      ('M3dView',
                                                       'ColorTable'),
                                                      'in')],
                                            'defaults': {'table': ('M3dView',
                                                                   'ColorTable',
                                                                   'kActiveColors')},
                                            'deprecated': False,
                                            'doc': "\r\nReturns the value of the color at the given index in the application's color table.",
                                            'inArgs': ['index', 'table'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The color',
                                                           'qualifiers': [],
                                                           'type': 'MColor'},
                                            'returnType': 'MColor',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'index': ['unsigned'],
                                                               'table': []},
                                            'types': {'index': 'uint',
                                                      'table': ('M3dView',
                                                                'ColorTable')}}],
                          'colorMask': [{'argInfo': {'a': {'doc': 'Alpha color mask flag.',
                                                           'type': 'bool'},
                                                     'b': {'doc': 'Blue color mask flag. ',
                                                           'type': 'bool'},
                                                     'g': {'doc': 'Green color mask flag. ',
                                                           'type': 'bool'},
                                                     'r': {'doc': 'Red color mask flag. ',
                                                           'type': 'bool'}},
                                         'args': [('r', 'bool', 'out'),
                                                  ('g', 'bool', 'out'),
                                                  ('b', 'bool', 'out'),
                                                  ('a', 'bool', 'out')],
                                         'defaults': {},
                                         'deprecated': True,
                                         'doc': '\n This method is obsolete. \n',
                                         'inArgs': [],
                                         'inverse': ('setColorMask',
                                                     False),
                                         'outArgs': ['r', 'g', 'b', 'a'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'a': ['&'],
                                                            'b': ['&'],
                                                            'g': ['&'],
                                                            'r': ['&']},
                                         'types': {'a': 'bool',
                                                   'b': 'bool',
                                                   'g': 'bool',
                                                   'r': 'bool'}}],
                          'disallowPolygonOffset': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the current state of the disallow polygon offset bit. See setDisallowPolygonOffset for more information.',
                                                     'inArgs': [],
                                                     'inverse': ('setDisallowPolygonOffset',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                          'display': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nMac OS X and Windows. \r\n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The OpenGL context. On 32-bit OS X this is an AGLContext. On 64-bit OS X this is an NSOpenGLContext pointer. On Windows this is an HGLRC.',
                                                      'qualifiers': [],
                                                      'type': ('M3dView',
                                                               'MGLContext')},
                                       'returnType': ('M3dView',
                                                      'MGLContext'),
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                          'displayStatus': [{'argInfo': {'path': {'doc': 'the DAG path to get. ',
                                                                  'type': 'MDagPath'}},
                                             'args': [('path',
                                                       'MDagPath',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the display status of the given DAG path.',
                                             'inArgs': ['path'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Display status for the DAG',
                                                            'qualifiers': [],
                                                            'type': ('M3dView',
                                                                     'DisplayStatus')},
                                             'returnType': ('M3dView',
                                                            'DisplayStatus'),
                                             'static': True,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'path': ['const',
                                                                         '&']},
                                             'types': {'path': 'MDagPath'}}],
                          'displayStyle': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the display style for this 3d view. The display style can be wireframe, flat-shaded, or smooth-shaded.',
                                            'inArgs': [],
                                            'inverse': ('setDisplayStyle',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The display style for this view',
                                                           'qualifiers': [],
                                                           'type': ('M3dView',
                                                                    'DisplayStyle')},
                                            'returnType': ('M3dView',
                                                           'DisplayStyle'),
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                          'drawText': [{'argInfo': {'position': {'doc': 'Position in space to draw at ',
                                                                 'type': 'MPoint'},
                                                    'text': {'doc': 'Text to draw ',
                                                             'type': 'MString'},
                                                    'textPosition': {'doc': 'Text position relative to the point',
                                                                     'type': ('M3dView',
                                                                              'TextPosition')}},
                                        'args': [('text',
                                                  'MString',
                                                  'in'),
                                                 ('position',
                                                  'MPoint',
                                                  'in'),
                                                 ('textPosition',
                                                  ('M3dView',
                                                   'TextPosition'),
                                                  'in')],
                                        'defaults': {'textPosition': ('M3dView',
                                                                      'TextPosition',
                                                                      'kLeft')},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': ['text',
                                                   'position',
                                                   'textPosition'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'position': ['const'],
                                                           'text': ['const',
                                                                    '&'],
                                                           'textPosition': []},
                                        'types': {'position': 'MPoint',
                                                  'text': 'MString',
                                                  'textPosition': ('M3dView',
                                                                   'TextPosition')}}],
                          'endGL': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': '\n This method is obsolete. \n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                          'endProjMatrixOverride': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': True,
                                                     'doc': '\n This method is obsolete. \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                          'endSelect': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFinish a selection sequence. Result is stored in the buffer passed in the beginSelect call.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Number of hits. ',
                                                        'qualifiers': [],
                                                        'type': ('M3dView',
                                                                 'GLint')},
                                         'returnType': ('M3dView',
                                                        'GLint'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'endXorDrawing': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReset the context to non-exclusive-or (non-XOR) screen drawing.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                          'filteredObjectList': [{'argInfo': {'list': {'doc': 'The list of objects left after filtering.',
                                                                       'type': 'MSelectionList'}},
                                                  'args': [('list',
                                                            'MSelectionList',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns a selection list containing all of the objects that remain after filtering is applied to the view.',
                                                  'inArgs': [],
                                                  'outArgs': ['list'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'list': ['&']},
                                                  'types': {'list': 'MSelectionList'}}],
                          'get3dView': [{'argInfo': {'index': {'doc': 'index of the view to get ',
                                                               'type': 'uint'},
                                                     'view': {'doc': 'storage for the returned view',
                                                              'type': 'M3dView'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in'),
                                                  ('view',
                                                   'M3dView',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the 3D view at the given index.',
                                         'inArgs': ['index'],
                                         'outArgs': ['view'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': True,
                                         'typeQualifiers': {'index': ['const',
                                                                      'unsigned'],
                                                            'view': ['&']},
                                         'types': {'index': 'uint',
                                                   'view': 'M3dView'}}],
                          'getCamera': [{'argInfo': {'camera': {'doc': 'Dag path for the camera (allocated by caller)',
                                                                'type': 'MDagPath'}},
                                         'args': [('camera',
                                                   'MDagPath',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nGet the camera for this view.',
                                         'inArgs': [],
                                         'inverse': ('setCamera', False),
                                         'outArgs': ['camera'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'camera': ['&']},
                                         'types': {'camera': 'MDagPath'}}],
                          'getColorIndexAndTable': [{'argInfo': {'glindex': {'doc': 'Value of the OpenGL color-index to retrieve ',
                                                                             'type': 'uint'},
                                                                 'index': {'doc': 'Returned ColorTable index ',
                                                                           'type': 'uint'},
                                                                 'table': {'doc': 'Returned ColorTable',
                                                                           'type': ('M3dView',
                                                                                    'ColorTable')}},
                                                     'args': [('glindex',
                                                               'uint',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'out'),
                                                              ('table',
                                                               ('M3dView',
                                                                'ColorTable'),
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the color table and index representing the given OpenGL color-index value. This method is useful when converting color indices obtained from glReadPixels(GL_COLOR_INDEX) to Maya color-index values suitable for use with the colorAtIndex and setDrawColor methods.',
                                                     'inArgs': ['glindex'],
                                                     'outArgs': ['index',
                                                                 'table'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'glindex': ['unsigned'],
                                                                        'index': ['unsigned',
                                                                                  '&'],
                                                                        'table': ['&']},
                                                     'types': {'glindex': 'uint',
                                                               'index': 'uint',
                                                               'table': ('M3dView',
                                                                         'ColorTable')}}],
                          'getLightCount': [{'argInfo': {'count': {'doc': 'The number of visible lights for the view. ',
                                                                   'type': 'uint'},
                                                         'visible': {'doc': 'Specify whether to count visible lights only. By Default this is set true.',
                                                                     'type': 'bool'}},
                                             'args': [('count',
                                                       'uint',
                                                       'out'),
                                                      ('visible',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'visible': True},
                                             'deprecated': False,
                                             'doc': '\r\nGet the number of lights for the view.',
                                             'inArgs': ['visible'],
                                             'outArgs': ['count'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'count': ['unsigned',
                                                                          '&'],
                                                                'visible': []},
                                             'types': {'count': 'uint',
                                                       'visible': 'bool'}}],
                          'getLightIndex': [{'argInfo': {'lightIndex': {'doc': 'The internal light index (returned)',
                                                                        'type': 'uint'},
                                                         'lightNumber': {'doc': 'The number of the light to check. ',
                                                                         'type': 'uint'}},
                                             'args': [('lightNumber',
                                                       'uint',
                                                       'in'),
                                                      ('lightIndex',
                                                       'uint',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the internal light index for a given light number',
                                             'inArgs': ['lightNumber'],
                                             'outArgs': ['lightIndex'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'lightIndex': ['unsigned',
                                                                               '&'],
                                                                'lightNumber': ['unsigned']},
                                             'types': {'lightIndex': 'uint',
                                                       'lightNumber': 'uint'}}],
                          'getLightPath': [{'argInfo': {'lightNumber': {'doc': 'Number of the light interested in ',
                                                                        'type': 'uint'},
                                                        'lightPath': {'doc': 'Path to light.',
                                                                      'type': 'MDagPath'}},
                                            'args': [('lightNumber',
                                                      'uint',
                                                      'in'),
                                                     ('lightPath',
                                                      'MDagPath',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGet the path to a certain light.',
                                            'inArgs': ['lightNumber'],
                                            'outArgs': ['lightPath'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'lightNumber': ['unsigned'],
                                                               'lightPath': ['&']},
                                            'types': {'lightNumber': 'uint',
                                                      'lightPath': 'MDagPath'}}],
                          'getLightingMode': [{'argInfo': {'mode': {'doc': 'The lighting mode for the view.',
                                                                    'type': ('M3dView',
                                                                             'LightingMode')}},
                                               'args': [('mode',
                                                         ('M3dView',
                                                          'LightingMode'),
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the current lighting mode for the view.',
                                               'inArgs': [],
                                               'outArgs': ['mode'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'mode': ['&']},
                                               'types': {'mode': ('M3dView',
                                                                  'LightingMode')}}],
                          'getM3dViewFromModelEditor': [{'argInfo': {'name': {'doc': 'The name of the model editor. ',
                                                                              'type': 'MString'},
                                                                     'view': {'doc': 'The M3dView from the model editor.',
                                                                              'type': 'M3dView'}},
                                                         'args': [('name',
                                                                   'MString',
                                                                   'in'),
                                                                  ('view',
                                                                   'M3dView',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGiven the name of a model editor, get the  M3dView  used by that editor. If this fails, then a editor with the given name could not be located.',
                                                         'inArgs': ['name'],
                                                         'outArgs': ['view'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': True,
                                                         'typeQualifiers': {'name': ['const',
                                                                                     '&'],
                                                                            'view': ['&']},
                                                         'types': {'name': 'MString',
                                                                   'view': 'M3dView'}}],
                          'getM3dViewFromModelPanel': [{'argInfo': {'name': {'doc': 'The name of the model panel. ',
                                                                             'type': 'MString'},
                                                                    'view': {'doc': 'The M3dView from the model panel.',
                                                                             'type': 'M3dView'}},
                                                        'args': [('name',
                                                                  'MString',
                                                                  'in'),
                                                                 ('view',
                                                                  'M3dView',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGiven the name of a model panel, get the  M3dView  used by that panel. If this fails, then a panel with the given name could not be located.',
                                                        'inArgs': ['name'],
                                                        'outArgs': ['view'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'name': ['const',
                                                                                    '&'],
                                                                           'view': ['&']},
                                                        'types': {'name': 'MString',
                                                                  'view': 'M3dView'}}],
                          'getRendererName': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the name of the current renderer being used for drawing to this view. The current possible return values are:',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The name of the current renderer.',
                                                              'qualifiers': [],
                                                              'type': ('M3dView',
                                                                       'RendererName')},
                                               'returnType': ('M3dView',
                                                              'RendererName'),
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'getRendererString': [{'argInfo': {'stringName': {'doc': 'string name (returned).',
                                                                            'type': 'MString'}},
                                                 'args': [('stringName',
                                                           'MString',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': ['stringName'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'stringName': ['&']},
                                                 'types': {'stringName': 'MString'}}],
                          'getScreenPosition': [{'argInfo': {'x': {'doc': '- x coordinate of the upper-left corner of the view ',
                                                                   'type': 'int'},
                                                             'y': {'doc': '- y coordinate of the upper-left corner of the view ',
                                                                   'type': 'int'}},
                                                 'args': [('x',
                                                           'int',
                                                           'out'),
                                                          ('y',
                                                           'int',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the current position of this view window in screen coordinates.',
                                                 'inArgs': [],
                                                 'outArgs': ['x', 'y'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'x': ['&'],
                                                                    'y': ['&']},
                                                 'types': {'x': 'int',
                                                           'y': 'int'}}],
                          'hiliteColor': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the color for hilited objects.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The hilite color',
                                                          'qualifiers': [],
                                                          'type': 'MColor'},
                                           'returnType': 'MColor',
                                           'static': True,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                          'initNames': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReset the name stack. Valid only when  beginSelect()  has been called. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'isBackgroundGradient': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns whether a gradient is being used as the background color.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': ' true background is a color gradient  false background is a solid color  ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': True,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                          'isLightVisible': [{'argInfo': {'lightNumber': {'doc': 'The number of the light to check. ',
                                                                          'type': 'uint'},
                                                          'visible': {'doc': 'Whether the light is visible or not.',
                                                                      'type': 'bool'}},
                                              'args': [('lightNumber',
                                                        'uint',
                                                        'in'),
                                                       ('visible',
                                                        'bool',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFind out if a light is visible in the view',
                                              'inArgs': ['lightNumber'],
                                              'outArgs': ['visible'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'lightNumber': ['unsigned'],
                                                                 'visible': ['&']},
                                              'types': {'lightNumber': 'uint',
                                                        'visible': 'bool'}}],
                          'isShadeActiveOnly': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nReturns  true  if this view's display style is shaded for objects that are active and wireframe otherwise.",
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true Only active objects are shaded if this view is in shaded mode  false All objects are shaded if this view is in shaded mode  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                          'isVisible': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns true if this viewport is visible.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'True if this viewport is visible',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'leadColor': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the color for lead objects.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The lead color',
                                                        'qualifiers': [],
                                                        'type': 'MColor'},
                                         'returnType': 'MColor',
                                         'static': True,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'liveColor': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the color for live objects.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The live color',
                                                        'qualifiers': [],
                                                        'type': 'MColor'},
                                         'returnType': 'MColor',
                                         'static': True,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'loadName': [{'argInfo': {'name': {'doc': 'Name to be loaded onto the top of the stack. ',
                                                             'type': ('M3dView',
                                                                      'GLuint')}},
                                        'args': [('name',
                                                  ('M3dView', 'GLuint'),
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReplace the top of the name stack with the given name. Valid only when  beginSelect()  has been called.',
                                        'inArgs': ['name'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'name': []},
                                        'types': {'name': ('M3dView',
                                                           'GLuint')}}],
                          'makeSharedContextCurrent': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nmakes the shared context current. If in DirectX mode it does nothing.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                          'modelViewMatrix': [{'argInfo': {'modelViewMatrix': {'doc': 'A place to store the modelview matrix',
                                                                               'type': 'MMatrix'}},
                                               'args': [('modelViewMatrix',
                                                         'MMatrix',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the modelview matrix currently being used by OpenGL in the current view',
                                               'inArgs': [],
                                               'outArgs': ['modelViewMatrix'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'modelViewMatrix': ['&']},
                                               'types': {'modelViewMatrix': 'MMatrix'}}],
                          'multipleDrawEnabled': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method returns the multiple draw enable state for this view.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                          'multipleDrawPassCount': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': True,
                                                     'doc': '\n This method is obsolete. \n',
                                                     'inArgs': [],
                                                     'inverse': ('setMultipleDrawPassCount',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': ' The number of multiple draw passes that will be made.   ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                          'numActiveColors': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the number of active object colors in the internal application color table.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The number of active colors',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'numDormantColors': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the number of dormant object colors in the internal application color table.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of dormant colors',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                          'numUserDefinedColors': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the number of user defined colors in the internal application color table. These colors may be changed by the user and assigned to specific objects. See the methods of  MFnDagNode  for information on assigning user defined colors to individual objects.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The number of user defined colors',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                          'numberOf3dViews': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the number of 3D views currently in existance.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                          'objectDisplay': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns a display object mask that indicates which object types are drawn in the current view.',
                                             'inArgs': [],
                                             'inverse': ('setObjectDisplay',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': "The display object mask which can be bit 'AND'ed against the M3dView::DisplayObjects enum.",
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                          'objectListFilterName': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the current object list filter name. If none then an empty string will be returned.',
                                                    'inArgs': [],
                                                    'inverse': ('setObjectListFilterName',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Filter name.',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                          'playblastPortHeight': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the port height of current playblast. Valid only when playblast command has been called. Otherwise, an invalid value 0 is returned.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The height of current playblast.',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                          'playblastPortWidth': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the port width of current playblast. Valid only when playblast command has been called. Otherwise, an invalid value 0 is returned.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The port width of current playblast.',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                          'pluginObjectDisplay': [{'argInfo': {'pluginDisplayFilter': {'doc': 'The name of the plugin display filter. ',
                                                                                       'type': 'MString'}},
                                                   'args': [('pluginDisplayFilter',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns true if the plugin display filter specified by the pluginDisplayFilter is enabled in the current view.',
                                                   'inArgs': ['pluginDisplayFilter'],
                                                   'inverse': ('setPluginObjectDisplay',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'true if the plugin display filter is enabled',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'pluginDisplayFilter': ['const',
                                                                                              '&']},
                                                   'types': {'pluginDisplayFilter': 'MString'}}],
                          'popName': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nRemoves the top of the name stack. Valid only when  beginSelect()  has been called. \r\n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                          'popViewport': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nPop the current viewport off of the viewport stack.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                          'portHeight': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the height of the current viewport.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The height of this viewport',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                          'portWidth': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the width of the current viewport.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The width of this viewport',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'projectionMatrix': [{'argInfo': {'projMat': {'doc': 'A place to store the projection matrix',
                                                                        'type': 'MMatrix'}},
                                                'args': [('projMat',
                                                          'MMatrix',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the projection matrix currently being used by OpenGL in the current view',
                                                'inArgs': [],
                                                'outArgs': ['projMat'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'projMat': ['&']},
                                                'types': {'projMat': 'MMatrix'}}],
                          'pushName': [{'argInfo': {'name': {'doc': 'Name to be loaded onto the top of the stack. ',
                                                             'type': ('M3dView',
                                                                      'GLuint')}},
                                        'args': [('name',
                                                  ('M3dView', 'GLuint'),
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nPush a new name on the name stack. Valid only when  beginSelect()  has been called.',
                                        'inArgs': ['name'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'name': []},
                                        'types': {'name': ('M3dView',
                                                           'GLuint')}}],
                          'pushViewport': [{'argInfo': {'height': {'doc': 'Height of the viewport.',
                                                                   'type': 'uint'},
                                                        'width': {'doc': 'Width of the viewport. ',
                                                                  'type': 'uint'},
                                                        'x': {'doc': 'Lower left corner of viewport (x coordinate). ',
                                                              'type': 'uint'},
                                                        'y': {'doc': 'Lower left corner of viewport (y coordinate). ',
                                                              'type': 'uint'}},
                                            'args': [('x', 'uint', 'in'),
                                                     ('y', 'uint', 'in'),
                                                     ('width',
                                                      'uint',
                                                      'in'),
                                                     ('height',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the current viewport dimensions. Will keep track of the last viewport dimensions on a stack. When finished with this viewport, the current dimensions should be removed from the top of stack using  M3dView::popViewport() .',
                                            'inArgs': ['x',
                                                       'y',
                                                       'width',
                                                       'height'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'height': ['unsigned'],
                                                               'width': ['unsigned'],
                                                               'x': ['unsigned'],
                                                               'y': ['unsigned']},
                                            'types': {'height': 'uint',
                                                      'width': 'uint',
                                                      'x': 'uint',
                                                      'y': 'uint'}}],
                          'readBufferTo2dTexture': [{'argInfo': {'height': {'doc': 'Number of pixels in y to read.',
                                                                            'type': 'uint'},
                                                                 'width': {'doc': 'Number of pixels in x to read. ',
                                                                           'type': 'uint'},
                                                                 'x': {'doc': 'Start position x to read. ',
                                                                       'type': 'short'},
                                                                 'y': {'doc': 'Start position y to read. ',
                                                                       'type': 'short'}},
                                                     'args': [('x',
                                                               'short',
                                                               'in'),
                                                              ('y',
                                                               'short',
                                                               'in'),
                                                              ('width',
                                                               'uint',
                                                               'in'),
                                                              ('height',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': True,
                                                     'doc': '\n This method is obsolete. \n',
                                                     'inArgs': ['x',
                                                                'y',
                                                                'width',
                                                                'height'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'height': ['unsigned'],
                                                                        'width': ['unsigned'],
                                                                        'x': ['unsigned'],
                                                                        'y': ['unsigned']},
                                                     'types': {'height': 'uint',
                                                               'width': 'uint',
                                                               'x': 'short',
                                                               'y': 'short'}}],
                          'readColorBuffer': [{'argInfo': {'image': {'doc': 'The image contains the frame buffer pixels. ',
                                                                     'type': 'MImage'},
                                                           'readRGBA': {'doc': 'Read the image back in RGBA format. By default the format is BGRA.',
                                                                        'type': 'bool'}},
                                               'args': [('image',
                                                         'MImage',
                                                         'in'),
                                                        ('readRGBA',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'readRGBA': False},
                                               'deprecated': True,
                                               'doc': '\n This method is obsolete. \n',
                                               'inArgs': ['image',
                                                          'readRGBA'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'image': ['&'],
                                                                  'readRGBA': []},
                                               'types': {'image': 'MImage',
                                                         'readRGBA': 'bool'}}],
                          'readDepthMap': [{'argInfo': {'bufferPtr': {'doc': 'Pointer to depth data allocated by the caller. ',
                                                                      'type': 'uchar'},
                                                        'depthMapPrecision': {'doc': 'Enumerated depth precision.',
                                                                              'type': ('M3dView',
                                                                                       'DepthBufferFormat')},
                                                        'height': {'doc': 'Number of pixels in y to read. ',
                                                                   'type': 'uint'},
                                                        'width': {'doc': 'Number of pixels in x to read. ',
                                                                  'type': 'uint'},
                                                        'x': {'doc': 'Start position x to read. ',
                                                              'type': 'short'},
                                                        'y': {'doc': 'Start position y to read. ',
                                                              'type': 'short'}},
                                            'args': [('x',
                                                      'short',
                                                      'in'),
                                                     ('y',
                                                      'short',
                                                      'in'),
                                                     ('width',
                                                      'uint',
                                                      'in'),
                                                     ('height',
                                                      'uint',
                                                      'in'),
                                                     ('bufferPtr',
                                                      'uchar',
                                                      'in'),
                                                     ('depthMapPrecision',
                                                      ('M3dView',
                                                       'DepthBufferFormat'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': True,
                                            'doc': '\n This method is obsolete. \n',
                                            'inArgs': ['x',
                                                       'y',
                                                       'width',
                                                       'height',
                                                       'bufferPtr',
                                                       'depthMapPrecision'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'bufferPtr': ['unsigned',
                                                                             '*'],
                                                               'depthMapPrecision': [],
                                                               'height': ['unsigned'],
                                                               'width': ['unsigned'],
                                                               'x': ['unsigned'],
                                                               'y': ['unsigned']},
                                            'types': {'bufferPtr': 'uchar',
                                                      'depthMapPrecision': ('M3dView',
                                                                            'DepthBufferFormat'),
                                                      'height': 'uint',
                                                      'width': 'uint',
                                                      'x': 'short',
                                                      'y': 'short'}}],
                          'referenceLayerColor': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the color for objects which belong to a display layer whose display type is Reference. This color is also used for objects whose display override is set to Reference.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The reference layer color',
                                                                  'qualifiers': [],
                                                                  'type': 'MColor'},
                                                   'returnType': 'MColor',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                          'refresh': [{'argInfo': {'all': {'doc': 'If true then refresh all views, otherwise refresh this view. ',
                                                           'type': 'bool'},
                                                   'force': {'doc': 'If true then force views to refresh even if they do not require it.',
                                                             'type': 'bool'}},
                                       'args': [('all', 'bool', 'in'),
                                                ('force', 'bool', 'in')],
                                       'defaults': {'all': False,
                                                    'force': False},
                                       'deprecated': False,
                                       'doc': '\r\nRefresh the this view. If  all  is set to  true  then all of the 3d-view will be refreshed.',
                                       'inArgs': ['all', 'force'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'all': [],
                                                          'force': []},
                                       'types': {'all': 'bool',
                                                 'force': 'bool'}},
                                      {'argInfo': {'all': {'doc': 'If true then refresh all views, otherwise refresh this view. ',
                                                           'type': 'bool'},
                                                   'force': {'doc': 'If true then force views to refresh even if they do not require it. ',
                                                             'type': 'bool'},
                                                   'offscreen': {'doc': "Should the buffer be redrawn if it's offscreen?",
                                                                 'type': 'bool'}},
                                       'args': [('all', 'bool', 'in'),
                                                ('force', 'bool', 'in'),
                                                ('offscreen',
                                                 'bool',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nRefresh the this view. If  all  is set to  true  then all of the 3d-view will be refreshed.',
                                       'inArgs': ['all',
                                                  'force',
                                                  'offscreen'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'all': [],
                                                          'force': [],
                                                          'offscreen': []},
                                       'types': {'all': 'bool',
                                                 'force': 'bool',
                                                 'offscreen': 'bool'}},
                                      {'argInfo': {'buffer': {'doc': 'The MPxGlBuffer in which to draw the view.',
                                                              'type': 'MPxGlBuffer'}},
                                       'args': [('buffer',
                                                 'MPxGlBuffer',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nRefresh the this view into the GL buffer buffer.',
                                       'inArgs': ['buffer'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'buffer': ['&']},
                                       'types': {'buffer': 'MPxGlBuffer'}},
                                      {'argInfo': {'buffer': {'doc': 'The MPxGlBuffer in which to draw the view. ',
                                                              'type': 'MPxGlBuffer'},
                                                   'offscreen': {'doc': "Should the buffer be redrawn if it's offscreen?",
                                                                 'type': 'bool'}},
                                       'args': [('buffer',
                                                 'MPxGlBuffer',
                                                 'in'),
                                                ('offscreen',
                                                 'bool',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nRefresh the this view into the GL buffer buffer.',
                                       'inArgs': ['buffer', 'offscreen'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'buffer': ['&'],
                                                          'offscreen': []},
                                       'types': {'buffer': 'MPxGlBuffer',
                                                 'offscreen': 'bool'}},
                                      {'argInfo': {'buffer': {'doc': 'The MPxGlBuffer in which to draw the view. ',
                                                              'type': 'MPxGlBuffer'},
                                                   'offscreen': {'doc': "Should the buffer be redrawn if it's offscreen? ",
                                                                 'type': 'bool'},
                                                   'projMatrix': {'doc': 'Projection matrix to provide to openGL before drawing',
                                                                  'type': 'MMatrix'}},
                                       'args': [('buffer',
                                                 'MPxGlBuffer',
                                                 'in'),
                                                ('offscreen',
                                                 'bool',
                                                 'in'),
                                                ('projMatrix',
                                                 'MMatrix',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nRefresh the this view into the GL buffer buffer.',
                                       'inArgs': ['buffer',
                                                  'offscreen',
                                                  'projMatrix'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'buffer': ['&'],
                                                          'offscreen': [],
                                                          'projMatrix': ['const',
                                                                         '&']},
                                       'types': {'buffer': 'MPxGlBuffer',
                                                 'offscreen': 'bool',
                                                 'projMatrix': 'MMatrix'}}],
                          'renderOverrideName': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the current render override name. If none then an empty string will be returned.',
                                                  'inArgs': [],
                                                  'inverse': ('setRenderOverrideName',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Override name. ',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                          'rendererString': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the string name of the current renderer being used for drawing to this view.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'String name',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                          'scheduleRefresh': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSchedule a forced refresh for this 3d-view. This method may be called safely at any time from any thread. The refresh will occur on the main thread when Maya next becomes idle. If a refresh has already been scheduled for this view but has not yet occurred then this method will do nothing.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                          'scheduleRefreshAllViews': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSchedule a forced refresh for all 3d-views. This method may be called safely at any time from any thread. The refresh will occur on the main thread when Maya next becomes idle. If a refresh has already been scheduled but has not yet occurred then this method will do nothing.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                          'selectMode': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nTells if this  M3dView  is in selection mode.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'setCamera': [{'argInfo': {'camera': {'doc': 'Dag path of the camera for this view',
                                                                'type': 'MDagPath'}},
                                         'args': [('camera',
                                                   'MDagPath',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSet the camera for this view.',
                                         'inArgs': ['camera'],
                                         'inverse': ('getCamera', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'camera': ['&']},
                                         'types': {'camera': 'MDagPath'}}],
                          'setColorMask': [{'argInfo': {'a': {'doc': 'Alpha color mask flag.',
                                                              'type': 'bool'},
                                                        'b': {'doc': 'Blue color mask flag. ',
                                                              'type': 'bool'},
                                                        'g': {'doc': 'Green color mask flag. ',
                                                              'type': 'bool'},
                                                        'r': {'doc': 'Red color mask flag. ',
                                                              'type': 'bool'}},
                                            'args': [('r', 'bool', 'in'),
                                                     ('g', 'bool', 'in'),
                                                     ('b', 'bool', 'in'),
                                                     ('a', 'bool', 'in')],
                                            'defaults': {},
                                            'deprecated': True,
                                            'doc': '\n This method is obsolete. \n',
                                            'inArgs': ['r',
                                                       'g',
                                                       'b',
                                                       'a'],
                                            'inverse': ('colorMask',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'a': [],
                                                               'b': [],
                                                               'g': [],
                                                               'r': []},
                                            'types': {'a': 'bool',
                                                      'b': 'bool',
                                                      'g': 'bool',
                                                      'r': 'bool'}}],
                          'setDisallowPolygonOffset': [{'argInfo': {'v': {'doc': 'enable/disable the polygon offset',
                                                                          'type': 'bool'}},
                                                        'args': [('v',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nCertain Maya actions will use glPolygonOffset to offset polygons drawing into the depth buffer. This method controls this behavior. When true, it prevents Maya from altering the polygon offset parameters.',
                                                        'inArgs': ['v'],
                                                        'inverse': ('disallowPolygonOffset',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'v': []},
                                                        'types': {'v': 'bool'}}],
                          'setDisplayStyle': [{'argInfo': {'activeOnly': {'doc': 'Specifies whether only active objects are to be shaded in shaded mode.',
                                                                          'type': 'bool'},
                                                           'style': {'doc': 'The display style to be set for this view ',
                                                                     'type': ('M3dView',
                                                                              'DisplayStyle')}},
                                               'args': [('style',
                                                         ('M3dView',
                                                          'DisplayStyle'),
                                                         'in'),
                                                        ('activeOnly',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'activeOnly': False},
                                               'deprecated': False,
                                               'doc': '\r\nSets the display style for this view. The display style can be wireframe, flat-shaded, or smooth-shaded.',
                                               'inArgs': ['style',
                                                          'activeOnly'],
                                               'inverse': ('displayStyle',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'activeOnly': [],
                                                                  'style': []},
                                               'types': {'activeOnly': 'bool',
                                                         'style': ('M3dView',
                                                                   'DisplayStyle')}}],
                          'setDrawColor': [{'argInfo': {'index': {'doc': 'index of the color to draw in ',
                                                                  'type': 'uint'},
                                                        'table': {'doc': 'color table to index into',
                                                                  'type': ('M3dView',
                                                                           'ColorTable')}},
                                            'args': [('index',
                                                      'uint',
                                                      'in'),
                                                     ('table',
                                                      ('M3dView',
                                                       'ColorTable'),
                                                      'in')],
                                            'defaults': {'table': ('M3dView',
                                                                   'ColorTable',
                                                                   'kActiveColors')},
                                            'deprecated': True,
                                            'doc': '\n This method is obsolete. \n',
                                            'inArgs': ['index', 'table'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'index': ['unsigned'],
                                                               'table': []},
                                            'types': {'index': 'uint',
                                                      'table': ('M3dView',
                                                                'ColorTable')}},
                                           {'argInfo': {'color': {'doc': 'color to draw in',
                                                                  'type': 'MColor'}},
                                            'args': [('color',
                                                      'MColor',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': True,
                                            'doc': '\n This method is obsolete. \n',
                                            'inArgs': ['color'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'color': ['const',
                                                                         '&']},
                                            'types': {'color': 'MColor'}}],
                          'setDrawColorAndAlpha': [{'argInfo': {'color': {'doc': 'color to draw in',
                                                                          'type': 'MColor'}},
                                                    'args': [('color',
                                                              'MColor',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': True,
                                                    'doc': '\n This method is obsolete. \n',
                                                    'inArgs': ['color'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'color': ['const',
                                                                                 '&']},
                                                    'types': {'color': 'MColor'}}],
                          'setMultipleDrawEnable': [{'argInfo': {'enable': {'doc': 'If true, then multiple draw is enabled. ',
                                                                            'type': 'bool'}},
                                                     'args': [('enable',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': True,
                                                     'doc': '\n This method is obsolete. \n',
                                                     'inArgs': ['enable'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'enable': []},
                                                     'types': {'enable': 'bool'}}],
                          'setMultipleDrawPassCount': [{'argInfo': {'count': {'doc': 'The number of multiple draw passes.',
                                                                              'type': 'uint'}},
                                                        'args': [('count',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': True,
                                                        'doc': '\n This method is obsolete. \n',
                                                        'inArgs': ['count'],
                                                        'inverse': ('multipleDrawPassCount',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'count': ['unsigned']},
                                                        'types': {'count': 'uint'}}],
                          'setObjectDisplay': [{'argInfo': {'displayMask': {'doc': 'The display object mask made with M3dView::DisplayObjects enum',
                                                                            'type': 'uint'}},
                                                'args': [('displayMask',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets a display object mask that indicates which object types are drawn in current view. By default every thing is displayed.',
                                                'inArgs': ['displayMask'],
                                                'inverse': ('objectDisplay',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'displayMask': ['unsigned']},
                                                'types': {'displayMask': 'uint'}}],
                          'setObjectListFilterName': [{'argInfo': {'name': {'doc': 'Name of the filter.',
                                                                            'type': 'MString'}},
                                                       'args': [('name',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet the name of the object list filter ( MObjectListFilter ) to use.',
                                                       'inArgs': ['name'],
                                                       'inverse': ('objectListFilterName',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'name': ['const',
                                                                                   '&']},
                                                       'types': {'name': 'MString'}}],
                          'setPluginObjectDisplay': [{'argInfo': {'on': {'doc': 'Enable or disable the plugin display filter.',
                                                                         'type': 'bool'},
                                                                  'pluginDisplayFilter': {'doc': 'The name of the plugin display filter. ',
                                                                                          'type': 'MString'}},
                                                      'args': [('pluginDisplayFilter',
                                                                'MString',
                                                                'in'),
                                                               ('on',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nEnables or disables a user-defined display filter (i.e. one which was registered using  MFnPlugin::registerDisplayFilter()  or the 'pluginDisplayFilter' command).",
                                                      'inArgs': ['pluginDisplayFilter',
                                                                 'on'],
                                                      'inverse': ('pluginObjectDisplay',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'on': [],
                                                                         'pluginDisplayFilter': ['const',
                                                                                                 '&']},
                                                      'types': {'on': 'bool',
                                                                'pluginDisplayFilter': 'MString'}}],
                          'setRenderOverrideName': [{'argInfo': {'name': {'doc': 'Name of the override.',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the name of a render override ( MHWRender::MRenderOverride ) to use.',
                                                     'inArgs': ['name'],
                                                     'inverse': ('renderOverrideName',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'name': ['const',
                                                                                 '&']},
                                                     'types': {'name': 'MString'}}],
                          'setShowObjectFilterNameInHUD': [{'argInfo': {'show': {'doc': 'If true, show the filter UI name in the HUD',
                                                                                 'type': 'bool'}},
                                                            'args': [('show',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSets whether or not to display the object filter UI name in the heads up display when an object filter is active. This string is concatenated with the camera name.',
                                                            'inArgs': ['show'],
                                                            'inverse': ('showObjectFilterNameInHUD',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'show': []},
                                                            'types': {'show': 'bool'}}],
                          'setShowViewSelectedChildren': [{'argInfo': {'show': {'doc': 'true if all of the children of view selected objects should be displayed. true is the default behavior for view selected.',
                                                                                'type': 'bool'}},
                                                           'args': [('show',
                                                                     'bool',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method changes the way that view selected works. By default, view selected with show all of the children of the objects in the view selected set. If false is passed to this method, then only the obejcts in the view selected set and their shapes will be drawn.',
                                                           'inArgs': ['show'],
                                                           'inverse': ('showViewSelectedChildren',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'show': []},
                                                           'types': {'show': 'bool'}}],
                          'setUserDefinedColor': [{'argInfo': {'color': {'doc': 'color to set to',
                                                                         'type': 'MColor'},
                                                               'index': {'doc': 'index into the user defined color ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in'),
                                                            ('color',
                                                             'MColor',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the user defined color at the given index. Valid indices range between zero and the number of user defined colors.',
                                                   'inArgs': ['index',
                                                              'color'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'color': ['const',
                                                                                '&'],
                                                                      'index': ['unsigned']},
                                                   'types': {'color': 'MColor',
                                                             'index': 'uint'}}],
                          'setViewSelectedPrefix': [{'argInfo': {'prefix': {'doc': 'The prefix to use.',
                                                                            'type': 'MString'}},
                                                     'args': [('prefix',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the prefix for the camera name as displayed in the heads up display when view selected is enabled. The prefix is concatenated with the camera name.',
                                                     'inArgs': ['prefix'],
                                                     'inverse': ('viewSelectedPrefix',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'prefix': ['const',
                                                                                   '&']},
                                                     'types': {'prefix': 'MString'}}],
                          'showObjectFilterNameInHUD': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns whether the object filter UI name is shown in the heads up display when an object filter is active.',
                                                         'inArgs': [],
                                                         'inverse': ('setShowObjectFilterNameInHUD',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'True if the filter UI name is shown',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                          'showViewSelectedChildren': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns turn if view selected shows all of the children of the obejcts that are flagged for view selected.',
                                                        'inArgs': [],
                                                        'inverse': ('setShowViewSelectedChildren',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'true if the children of view selected objects are drawn.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                          'templateColor': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the value of the template color.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The template color',
                                                            'qualifiers': [],
                                                            'type': 'MColor'},
                                             'returnType': 'MColor',
                                             'static': True,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                          'textureMode': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nTells if this  M3dView  is in texture mode.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                          'twoSidedLighting': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn true if the Two-sided lighting mode is enabled.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true if the Two-sided lighting mode is enabled.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                          'updateViewingParameters': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': "\r\nThis method tells the camera to set the view's transformation matrix.",
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                          'userDefinedColorIndex': [{'argInfo': {'index': {'doc': 'Index into user-defined colors ',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the index for the given user-defined color. Valid values for the index argument range between zero and the number of user-defined colors minus one.',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Index of user-defined color into the active and dormant tables',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'index': ['unsigned']},
                                                     'types': {'index': 'uint'}}],
                          'usingDefaultMaterial': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns true if the view is currently displaying objects using the default material.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The default material state. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                          'usingMipmappedTextures': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns if the view is using mipmapped texture display.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                          'viewIsFiltered': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the state of view filtering for this view.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'True if the view is filtered.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                          'viewSelectedPrefix': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the Returns the prefix used when displaying the camera name in the heads up display when view selected in on.',
                                                  'inArgs': [],
                                                  'inverse': ('setViewSelectedPrefix',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The prefix.',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                          'viewToObjectSpace': [{'argInfo': {'localMatrixInverse': {'doc': 'the inclusive matrix inverse of the object in question ',
                                                                                    'type': 'MMatrix'},
                                                             'oPt': {'doc': '(returned) the source of the ray in object space ',
                                                                     'type': 'MPoint'},
                                                             'oVector': {'doc': '(returned) the direction of the ray in object space',
                                                                         'type': 'MVector'},
                                                             'x_pos': {'doc': 'the x position of the point in port coordinates ',
                                                                       'type': 'short'},
                                                             'y_pos': {'doc': 'the y position of the point in port coordinates ',
                                                                       'type': 'short'}},
                                                 'args': [('x_pos',
                                                           'short',
                                                           'in'),
                                                          ('y_pos',
                                                           'short',
                                                           'in'),
                                                          ('localMatrixInverse',
                                                           'MMatrix',
                                                           'in'),
                                                          ('oPt',
                                                           'MPoint',
                                                           'out'),
                                                          ('oVector',
                                                           'MVector',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nTakes a point in port coordinates and returns a corresponding ray in object coordinates.',
                                                 'inArgs': ['x_pos',
                                                            'y_pos',
                                                            'localMatrixInverse'],
                                                 'outArgs': ['oPt',
                                                             'oVector'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'localMatrixInverse': ['const',
                                                                                           '&'],
                                                                    'oPt': ['&'],
                                                                    'oVector': ['&'],
                                                                    'x_pos': [],
                                                                    'y_pos': []},
                                                 'types': {'localMatrixInverse': 'MMatrix',
                                                           'oPt': 'MPoint',
                                                           'oVector': 'MVector',
                                                           'x_pos': 'short',
                                                           'y_pos': 'short'}}],
                          'viewToWorld': [{'argInfo': {'worldPt': {'doc': '(returned) the source of the ray ',
                                                                   'type': 'MPoint'},
                                                       'worldVector': {'doc': '(returned) the direction of the ray',
                                                                       'type': 'MVector'},
                                                       'x_pos': {'doc': 'the x position of the point in port coordinates ',
                                                                 'type': 'short'},
                                                       'y_pos': {'doc': 'the y position of the point in port coordinates ',
                                                                 'type': 'short'}},
                                           'args': [('x_pos',
                                                     'short',
                                                     'in'),
                                                    ('y_pos',
                                                     'short',
                                                     'in'),
                                                    ('worldPt',
                                                     'MPoint',
                                                     'out'),
                                                    ('worldVector',
                                                     'MVector',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nTakes a point in port coordinates and returns a corresponding ray in world coordinates.',
                                           'inArgs': ['x_pos', 'y_pos'],
                                           'outArgs': ['worldPt',
                                                       'worldVector'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'worldPt': ['&'],
                                                              'worldVector': ['&'],
                                                              'x_pos': [],
                                                              'y_pos': []},
                                           'types': {'worldPt': 'MPoint',
                                                     'worldVector': 'MVector',
                                                     'x_pos': 'short',
                                                     'y_pos': 'short'}},
                                          {'argInfo': {'farClipPt': {'doc': '(returned) point on far clipping plane',
                                                                     'type': 'MPoint'},
                                                       'nearClipPt': {'doc': '(returned) point on near clipping plane ',
                                                                      'type': 'MPoint'},
                                                       'x_pos': {'doc': 'the x position of the point in port coordinates ',
                                                                 'type': 'short'},
                                                       'y_pos': {'doc': 'the y position of the point in port coordinates ',
                                                                 'type': 'short'}},
                                           'args': [('x_pos',
                                                     'short',
                                                     'in'),
                                                    ('y_pos',
                                                     'short',
                                                     'in'),
                                                    ('nearClipPt',
                                                     'MPoint',
                                                     'out'),
                                                    ('farClipPt',
                                                     'MPoint',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nTakes a point in port coordinates and returns a point on the near and far clipping planes.',
                                           'inArgs': ['x_pos', 'y_pos'],
                                           'outArgs': ['nearClipPt',
                                                       'farClipPt'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'farClipPt': ['&'],
                                                              'nearClipPt': ['&'],
                                                              'x_pos': [],
                                                              'y_pos': []},
                                           'types': {'farClipPt': 'MPoint',
                                                     'nearClipPt': 'MPoint',
                                                     'x_pos': 'short',
                                                     'y_pos': 'short'}}],
                          'viewport': [{'argInfo': {'height': {'doc': 'Height of the viewport.',
                                                               'type': 'uint'},
                                                    'width': {'doc': 'Width of the viewport. ',
                                                              'type': 'uint'},
                                                    'x': {'doc': 'Lower left corner of viewport (x coordinate). ',
                                                          'type': 'uint'},
                                                    'y': {'doc': 'Lower left corner of viewport (y coordinate). ',
                                                          'type': 'uint'}},
                                        'args': [('x', 'uint', 'out'),
                                                 ('y', 'uint', 'out'),
                                                 ('width',
                                                  'uint',
                                                  'out'),
                                                 ('height',
                                                  'uint',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nGet the current viewport dimensions.',
                                        'inArgs': [],
                                        'outArgs': ['x',
                                                    'y',
                                                    'width',
                                                    'height'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'height': ['unsigned',
                                                                      '&'],
                                                           'width': ['unsigned',
                                                                     '&'],
                                                           'x': ['unsigned',
                                                                 '&'],
                                                           'y': ['unsigned',
                                                                 '&']},
                                        'types': {'height': 'uint',
                                                  'width': 'uint',
                                                  'x': 'uint',
                                                  'y': 'uint'}}],
                          'widget': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nReturns the view's Qt widget.",
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': "A QWidget pointer to the Qt widget containing the view's drawing region, or NULL if the view's drawing region has not yet been created.",
                                                     'qualifiers': ['*'],
                                                     'type': ('M3dView',
                                                              'QWidget')},
                                      'returnType': ('M3dView',
                                                     'QWidget'),
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                          'window': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturns the native window for this view.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The X window',
                                                     'qualifiers': [],
                                                     'type': ('M3dView',
                                                              'MNativeWindowHdl')},
                                      'returnType': ('M3dView',
                                                     'MNativeWindowHdl'),
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                          'wireframeOnShaded': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn whether we draw wireframe in shaded mode.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'true if we draw wireframe in shaded mode.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                          'wireframeOnlyInShadedMode': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturn whether we are in shaded mode, but that only non shaded drawing should occur (wireframe).',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'true if we are in this mode.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                          'worldToView': [{'argInfo': {'worldPt': {'doc': 'the point to world space ',
                                                                   'type': 'MPoint'},
                                                       'x_pos': {'doc': '(returned) The x coordinate of the world point in port space. ',
                                                                 'type': 'short'},
                                                       'y_pos': {'doc': '(returned) The y coordinate of the world point in port space. ',
                                                                 'type': 'short'}},
                                           'args': [('worldPt',
                                                     'MPoint',
                                                     'in'),
                                                    ('x_pos',
                                                     'short',
                                                     'out'),
                                                    ('y_pos',
                                                     'short',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nconverts a point in world space to port space. The return value indicates if the point is not clipped.',
                                           'inArgs': ['worldPt'],
                                           'outArgs': ['x_pos', 'y_pos'],
                                           'returnInfo': {'doc': ' true point is not clipped  false point is undefined or outside frustum  ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'worldPt': ['const',
                                                                          '&'],
                                                              'x_pos': ['&'],
                                                              'y_pos': ['&']},
                                           'types': {'worldPt': 'MPoint',
                                                     'x_pos': 'short',
                                                     'y_pos': 'short'}}],
                          'writeColorBuffer': [{'argInfo': {'image': {'doc': 'The image containing the block of pixels to write ',
                                                                      'type': 'MImage'},
                                                            'x': {'doc': 'The location in screen space of the lower left corner (X) of the image to write. The default value is 0. ',
                                                                  'type': 'signed'},
                                                            'y': {'doc': 'The location in screen space of the lower left corner (Y) of the image to write. The default value is 0.',
                                                                  'type': 'signed'}},
                                                'args': [('image',
                                                          'MImage',
                                                          'in'),
                                                         ('x',
                                                          'signed',
                                                          'in'),
                                                         ('y',
                                                          'signed',
                                                          'in')],
                                                'defaults': {'x': '0',
                                                             'y': '0'},
                                                'deprecated': True,
                                                'doc': '\n This method is obsolete. \n',
                                                'inArgs': ['image',
                                                           'x',
                                                           'y'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'image': ['const',
                                                                             '&'],
                                                                   'x': ['short'],
                                                                   'y': ['short']},
                                                'types': {'image': 'MImage',
                                                          'x': 'signed',
                                                          'y': 'signed'}}],
                          'xray': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nReturn true if the X-Ray mode is enabled.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'true if the X-Ray mode is enabled.',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                    'types': {}}],
                          'xrayJoints': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturn true if the X-Ray Joints mode is enabled.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'true if the X-Ray Joints mode is enabled.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}]},
              'pymelEnums': {'ColorTable': "Enum('ColorTable', [('activeColors', 0), ('kActiveColors', 0), ('dormantColors', 2), ('kDormantColors', 2), ('templateColor', 5), ('kTemplateColor', 5), ('backgroundColor', 6), ('kBackgroundColor', 6)], multiKeys=True)",
                             'DepthBufferFormat': "Enum('DepthBufferFormat', [('k8', 0), ('kDepth_8', 0), ('float', 1), ('kDepth_Float', 1)], multiKeys=True)",
                             'DisplayObjects': "Enum('DisplayObjects', [('excludePluginShapes', -2147483648), ('kExcludePluginShapes', -2147483648), ('displayEverything', -1), ('kDisplayEverything', -1), ('displayNurbsCurves', 1), ('kDisplayNurbsCurves', 1), ('displayNurbsSurfaces', 2), ('kDisplayNurbsSurfaces', 2), ('displayMeshes', 4), ('kDisplayMeshes', 4), ('displayPlanes', 8), ('kDisplayPlanes', 8), ('displayLights', 16), ('kDisplayLights', 16), ('displayCameras', 32), ('kDisplayCameras', 32), ('displayJoints', 64), ('kDisplayJoints', 64), ('displayIkHandles', 128), ('kDisplayIkHandles', 128), ('displayDeformers', 256), ('kDisplayDeformers', 256), ('displayDynamics', 512), ('kDisplayDynamics', 512), ('displayParticleInstancers', 1024), ('kDisplayParticleInstancers', 1024), ('displayLocators', 2048), ('kDisplayLocators', 2048), ('displayDimensions', 4096), ('kDisplayDimensions', 4096), ('displaySelectHandles', 8192), ('kDisplaySelectHandles', 8192), ('displayPivots', 16384), ('kDisplayPivots', 16384), ('displayTextures', 32768), ('kDisplayTextures', 32768), ('displayGrid', 65536), ('kDisplayGrid', 65536), ('displayCVs', 131072), ('kDisplayCVs', 131072), ('displayHulls', 262144), ('kDisplayHulls', 262144), ('displayStrokes', 524288), ('kDisplayStrokes', 524288), ('displaySubdivSurfaces', 1048576), ('kDisplaySubdivSurfaces', 1048576), ('displayFluids', 2097152), ('kDisplayFluids', 2097152), ('displayFollicles', 4194304), ('kDisplayFollicles', 4194304), ('displayHairSystems', 8388608), ('kDisplayHairSystems', 8388608), ('displayImagePlane', 16777216), ('kDisplayImagePlane', 16777216), ('displayNCloths', 33554432), ('kDisplayNCloths', 33554432), ('displayNRigids', 67108864), ('kDisplayNRigids', 67108864), ('displayDynamicConstraints', 134217728), ('kDisplayDynamicConstraints', 134217728), ('displayManipulators', 268435456), ('kDisplayManipulators', 268435456), ('displayNParticles', 536870912), ('kDisplayNParticles', 536870912), ('excludeMotionTrails', 1073741824), ('kExcludeMotionTrails', 1073741824)], multiKeys=True)",
                             'DisplayStatus': "Enum('DisplayStatus', [('active', 0), ('kActive', 0), ('live', 1), ('kLive', 1), ('dormant', 2), ('kDormant', 2), ('invisible', 3), ('kInvisible', 3), ('hilite', 4), ('kHilite', 4), ('template', 5), ('kTemplate', 5), ('activeTemplate', 6), ('kActiveTemplate', 6), ('activeComponent', 7), ('kActiveComponent', 7), ('lead', 8), ('kLead', 8), ('intermediateObject', 9), ('kIntermediateObject', 9), ('activeAffected', 10), ('kActiveAffected', 10), ('noStatus', 11), ('kNoStatus', 11)], multiKeys=True)",
                             'DisplayStyle': "Enum('DisplayStyle', [('boundingBox', 0), ('kBoundingBox', 0), ('flatShaded', 1), ('kFlatShaded', 1), ('gouraudShaded', 2), ('kGouraudShaded', 2), ('wireFrame', 3), ('kWireFrame', 3), ('points', 4), ('kPoints', 4)], multiKeys=True)",
                             'LightingMode': "Enum('LightingMode', [('lightAll', 0), ('kLightAll', 0), ('lightSelected', 1), ('kLightSelected', 1), ('lightActive', 2), ('kLightActive', 2), ('lightDefault', 3), ('kLightDefault', 3), ('unused1', 4), ('kUnused1', 4), ('lightNone', 5), ('kLightNone', 5)], multiKeys=True)",
                             'LineStipplePattern': "Enum('LineStipplePattern', [('none', 0), ('kStippleNone', 0), ('dashed', 1), ('kStippleDashed', 1)], multiKeys=True)",
                             'RendererName': "Enum('RendererName', [('defaultQualityRenderer', 0), ('kDefaultQualityRenderer', 0), ('highQualityRenderer', 1), ('kHighQualityRenderer', 1), ('viewport2Renderer', 2), ('kViewport2Renderer', 2), ('externalRenderer', 3), ('kExternalRenderer', 3)], multiKeys=True)",
                             'TextPosition': "Enum('TextPosition', [('left', 0), ('kLeft', 0), ('center', 1), ('kCenter', 1), ('right', 2), ('kRight', 2)], multiKeys=True)"},
              'pymelMethods': {'colorMask': 'getColorMask',
                               'disallowPolygonOffset': 'getDisallowPolygonOffset',
                               'displayStyle': 'getDisplayStyle',
                               'multipleDrawPassCount': 'getMultipleDrawPassCount',
                               'objectDisplay': 'getObjectDisplay',
                               'objectListFilterName': 'getObjectListFilterName',
                               'pluginObjectDisplay': 'getPluginObjectDisplay',
                               'renderOverrideName': 'getRenderOverrideName',
                               'showObjectFilterNameInHUD': 'getShowObjectFilterNameInHUD',
                               'showViewSelectedChildren': 'getShowViewSelectedChildren',
                               'viewSelectedPrefix': 'getViewSelectedPrefix'}},
  'MAddRemoveAttrEdit': {'enums': {},
                         'methods': {'attributeName': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturns the name of the attribute that was added or removed.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The name of the attribute involved in this edit',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'editType': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nVirtual method used to return the edit type of this edit, which is  MEdit::kAddRemoveAttrEdit .',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'MEdit::kAddRemoveAttrEdit',
                                                                  'qualifiers': [],
                                                                  'type': ('MEdit',
                                                                           'EditType')},
                                                   'returnType': ('MEdit',
                                                                  'EditType'),
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                     'isAttributeAdded': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturns true if this edit is for an added attribute, false for a removed attribute.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                     'node': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns the depend node involved in this edit. The node can only be returned when the related reference or assembly is loaded. When the reference or assembly is unloaded, only the node name string may be queried successfully.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The node involved in this edit',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                     'nodeName': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of the node where the attribute was added or removed.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The name of the node involved in this edit',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}]},
                         'pymelEnums': {}},
  'MAngle': {'enums': {'Unit': {'valueDocs': {'angMinutes': 'Minutes of Arc.',
                                              'angSeconds': 'Seconds of Arc.',
                                              'degrees': 'Degrees.',
                                              'invalid': 'Invalid value.',
                                              'kAngMinutes': 'Minutes of Arc.',
                                              'kAngSeconds': 'Seconds of Arc.',
                                              'kDegrees': 'Degrees.',
                                              'kInvalid': 'Invalid value.',
                                              'kLast': 'Last enum value.',
                                              'kRadians': 'Radians.',
                                              'last': 'Last enum value.',
                                              'radians': 'Radians.'},
                                'values': "Enum('Unit', {'kInvalid': 0, 'kRadians': 1, 'kDegrees': 2, 'kAngMinutes': 3, 'kAngSeconds': 4, 'kLast': 5})"}},
             'invertibles': [('setInternalUnit', 'internalUnit'),
                             ('setValue', 'value'),
                             ('setUnit', 'unit')],
             'methods': {'as': [{'argInfo': {'otherUnit': {'doc': 'An element of the MAngle::Unit enum specifying the desired units ',
                                                           'type': ('MAngle',
                                                                    'Unit')}},
                                 'args': [('otherUnit',
                                           ('MAngle', 'Unit'),
                                           'in')],
                                 'defaults': {},
                                 'deprecated': False,
                                 'doc': '\r\nUnit conversion. \r\n',
                                 'inArgs': ['otherUnit'],
                                 'outArgs': [],
                                 'returnInfo': {'doc': 'The current value in the given units',
                                                'qualifiers': [],
                                                'type': 'double'},
                                 'returnType': 'double',
                                 'static': False,
                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                    'otherUnit': []},
                                 'types': {'otherUnit': ('MAngle',
                                                         'Unit')}}],
                         'asAngMinutes': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nConvert to minutes of arc. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'asAngSeconds': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nConvert to seconds of arc. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'asDegrees': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nConvert to degrees. \r\n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'asRadians': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nConvert to radians. \r\n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The current value in the radians ',
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'asUnits': [{'argInfo': {'otherUnit': {'doc': 'An element of the MAngle::Unit enum specifying the desired units ',
                                                                'type': ('MAngle',
                                                                         'Unit')}},
                                      'args': [('otherUnit',
                                                ('MAngle', 'Unit'),
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nUnit conversion. \r\n',
                                      'inArgs': ['otherUnit'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The current value in the given units',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'otherUnit': []},
                                      'types': {'otherUnit': ('MAngle',
                                                              'Unit')}}],
                         'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['*'],
                                                       'type': 'char'},
                                        'returnType': 'char',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'internalToUI': [{'argInfo': {'internalValue': {'doc': 'a value in internal units',
                                                                         'type': 'double'}},
                                           'args': [('internalValue',
                                                     'double',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nUnit conversion. \r\n',
                                           'inArgs': ['internalValue'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The value in UI units ',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': True,
                                           'typeQualifiers': {'internalValue': []},
                                           'types': {'internalValue': 'double'}}],
                         'internalUnit': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nInternal unit. \r\n',
                                           'inArgs': [],
                                           'inverse': ('setInternalUnit',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The internal unit for angles ',
                                                          'qualifiers': [],
                                                          'type': ('MAngle',
                                                                   'Unit')},
                                           'returnType': ('MAngle',
                                                          'Unit'),
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'setInternalUnit': [{'argInfo': {'internalUnit': {'doc': 'the internal unit for angles',
                                                                           'type': ('MAngle',
                                                                                    'Unit')}},
                                              'args': [('internalUnit',
                                                        ('MAngle',
                                                         'Unit'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': True,
                                              'doc': '\n This method is obsolete. \n',
                                              'inArgs': ['internalUnit'],
                                              'inverse': ('internalUnit',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'internalUnit': []},
                                              'types': {'internalUnit': ('MAngle',
                                                                         'Unit')}}],
                         'setUIUnit': [{'argInfo': {'newUnit': {'doc': 'and element of the MAngle::Unit enum.',
                                                                'type': ('MAngle',
                                                                         'Unit')}},
                                        'args': [('newUnit',
                                                  ('MAngle', 'Unit'),
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSet working unit. \r\n',
                                        'inArgs': ['newUnit'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': True,
                                        'typeQualifiers': {'newUnit': []},
                                        'types': {'newUnit': ('MAngle',
                                                              'Unit')}}],
                         'setUnit': [{'argInfo': {'newUnit': {'doc': 'An element of the MAngle::Unit enum',
                                                              'type': ('MAngle',
                                                                       'Unit')}},
                                      'args': [('newUnit',
                                                ('MAngle', 'Unit'),
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSet current unit. \r\n',
                                      'inArgs': ['newUnit'],
                                      'inverse': ('unit', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'newUnit': []},
                                      'types': {'newUnit': ('MAngle',
                                                            'Unit')}}],
                         'setValue': [{'argInfo': {'newValue': {'doc': 'The new value in the units currently in effect',
                                                                'type': 'double'}},
                                       'args': [('newValue',
                                                 'double',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSet current value. \r\n',
                                       'inArgs': ['newValue'],
                                       'inverse': ('value', True),
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'newValue': []},
                                       'types': {'newValue': 'double'}}],
                         'uiToInternal': [{'argInfo': {'uiValue': {'doc': 'a value in UI units',
                                                                   'type': 'double'}},
                                           'args': [('uiValue',
                                                     'double',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nUnit conversion. \r\n',
                                           'inArgs': ['uiValue'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The value in internal units. ',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': True,
                                           'typeQualifiers': {'uiValue': []},
                                           'types': {'uiValue': 'double'}}],
                         'uiUnit': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nWorking unit. \r\n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'An element of the MAngle::Unit enum ',
                                                    'qualifiers': [],
                                                    'type': ('MAngle',
                                                             'Unit')},
                                     'returnType': ('MAngle', 'Unit'),
                                     'static': True,
                                     'typeQualifiers': {},
                                     'types': {}}],
                         'unit': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nCurrent unit. \r\n',
                                   'inArgs': [],
                                   'inverse': ('setUnit', False),
                                   'outArgs': [],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': ('MAngle',
                                                           'Unit')},
                                   'returnType': ('MAngle', 'Unit'),
                                   'static': False,
                                   'typeQualifiers': {},
                                   'types': {}}],
                         'value': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nCurrent value. \r\n',
                                    'inArgs': [],
                                    'inverse': ('setValue', False),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'double'},
                                    'returnType': 'double',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}]},
             'pymelEnums': {'Unit': "Enum('Unit', [('invalid', 0), ('kInvalid', 0), ('radians', 1), ('kRadians', 1), ('degrees', 2), ('kDegrees', 2), ('angMinutes', 3), ('kAngMinutes', 3), ('angSeconds', 4), ('kAngSeconds', 4), ('last', 5), ('kLast', 5)], multiKeys=True)"},
             'pymelMethods': {'internalUnit': 'getInternalUnit',
                              'unit': 'getUnit',
                              'value': 'getValue'}},
  'MAnimControl': {'enums': {'PlaybackMode': {'valueDocs': {'kPlaybackLoop': 'Play continuously.',
                                                            'kPlaybackOnce': 'Play once then stop.',
                                                            'kPlaybackOscillate': 'Play forwards, then backwards continuously.',
                                                            'loop': 'Play continuously.',
                                                            'once': 'Play once then stop.',
                                                            'oscillate': 'Play forwards, then backwards continuously.'},
                                              'values': "Enum('PlaybackMode', {'kPlaybackOnce': 0, 'kPlaybackLoop': 1, 'kPlaybackOscillate': 2})"},
                             'PlaybackViewMode': {'valueDocs': {'active': 'Playback in only the active view.',
                                                                'all': 'Playback in all views.',
                                                                'kPlaybackViewActive': 'Playback in only the active view.',
                                                                'kPlaybackViewAll': 'Playback in all views.'},
                                                  'values': "Enum('PlaybackViewMode', {'kPlaybackViewAll': 0, 'kPlaybackViewActive': 1})"}},
                   'invertibles': [('setCurrentTime', 'currentTime'),
                                   ('setViewMode', 'viewMode'),
                                   ('setAnimationEndTime',
                                    'animationEndTime'),
                                   ('setPlaybackSpeed', 'playbackSpeed'),
                                   ('setAutoKeyMode', 'autoKeyMode'),
                                   ('setGlobalOutTangentType',
                                    'globalOutTangentType'),
                                   ('setMinTime', 'minTime'),
                                   ('setPlaybackBy', 'playbackBy'),
                                   ('setPlaybackMode', 'playbackMode'),
                                   ('setMaxTime', 'maxTime'),
                                   ('setGlobalInTangentType',
                                    'globalInTangentType'),
                                   ('setWeightedTangents',
                                    'weightedTangents'),
                                   ('setAnimationStartTime',
                                    'animationStartTime')],
                   'methods': {'animationEndTime': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn an  MTime  specifying the last frame of the animation, as specified by the Maya user in the Range Slider UI. This corresponds to the animationEndTime which can also be set and queried using the playbackOptions mel command.',
                                                     'inArgs': [],
                                                     'inverse': ('setAnimationEndTime',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'MTime'},
                                                     'returnType': 'MTime',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                               'animationStartTime': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn an  MTime  specifying the first frame of the animation, as specified by the Maya user in the Range Slider UI. This corresponds to the animationStartTime which can also be set and queried using the playbackOptions mel command.',
                                                       'inArgs': [],
                                                       'inverse': ('setAnimationStartTime',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'MTime'},
                                                       'returnType': 'MTime',
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                               'autoKeyMode': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the autoKeyMode.',
                                                'inArgs': [],
                                                'inverse': ('setAutoKeyMode',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                               'currentTime': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn an  MTime  instance containing the current animation frame.',
                                                'inArgs': [],
                                                'inverse': ('setCurrentTime',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'An MTime containing the current animation frame ',
                                                               'qualifiers': [],
                                                               'type': 'MTime'},
                                                'returnType': 'MTime',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                               'globalInTangentType': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturn the current global in tangent type.',
                                                        'inArgs': [],
                                                        'inverse': ('setGlobalInTangentType',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': ' MFnAnimCurve::TangentType the current global in tangent type  ',
                                                                       'qualifiers': [],
                                                                       'type': ('MFnAnimCurve',
                                                                                'TangentType')},
                                                        'returnType': ('MFnAnimCurve',
                                                                       'TangentType'),
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                               'globalOutTangentType': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturn the current global out tangent type.',
                                                         'inArgs': [],
                                                         'inverse': ('setGlobalOutTangentType',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The current global out tangent type',
                                                                        'qualifiers': [],
                                                                        'type': ('MFnAnimCurve',
                                                                                 'TangentType')},
                                                         'returnType': ('MFnAnimCurve',
                                                                        'TangentType'),
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                               'isPlaying': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn a value indicating whether Maya is currently playing the animation.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'isScrubbing': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn a value indicating whether interactive scrubbing is occuring while Maya is not currently playing an animation.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                               'maxTime': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn an  MTime  specifying the last frame of the current playback time range. This corresponds to the maxTime which can also be set and queried using the playbackOptions mel command. It does not represent the final frame of the total animation time unless the two coincide.',
                                            'inArgs': [],
                                            'inverse': ('setMaxTime',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'An MTime instance specifying the last frame of the playback time range ',
                                                           'qualifiers': [],
                                                           'type': 'MTime'},
                                            'returnType': 'MTime',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                               'minTime': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn an  MTime  specifying the first frame of the current playback time range. This corresponds to the minTime which can also be set and queried using the playbackOptions mel command. It does not represent the first frame of the total animation time unless the two coincide.',
                                            'inArgs': [],
                                            'inverse': ('setMinTime',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'An MTime instance specifying the first frame of the playback time range ',
                                                           'qualifiers': [],
                                                           'type': 'MTime'},
                                            'returnType': 'MTime',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                               'playBackward': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nStart playing the current animation backwards.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'playForward': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nStart playing the current animation forwards.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                               'playbackBy': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn a double specifying the increment between times viewed during the playing of the animation.',
                                               'inArgs': [],
                                               'inverse': ('setPlaybackBy',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'playbackMode': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the playback mode currently in effect.',
                                                 'inArgs': [],
                                                 'inverse': ('setPlaybackMode',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MAnimControl',
                                                                         'PlaybackMode')},
                                                 'returnType': ('MAnimControl',
                                                                'PlaybackMode'),
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'playbackSpeed': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the speed with with to play the animation.',
                                                  'inArgs': [],
                                                  'inverse': ('setPlaybackSpeed',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'setAnimationEndTime': [{'argInfo': {'newEndTime': {'doc': 'an MTime containing the new last frame',
                                                                                   'type': 'MTime'}},
                                                        'args': [('newEndTime',
                                                                  'MTime',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSet the value of the last frame in the animation.',
                                                        'inArgs': ['newEndTime'],
                                                        'inverse': ('animationEndTime',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'newEndTime': []},
                                                        'types': {'newEndTime': 'MTime'}}],
                               'setAnimationStartEndTime': [{'argInfo': {'newEndTime': {'doc': 'an MTime containing the new last frame',
                                                                                        'type': 'MTime'},
                                                                         'newStartTime': {'doc': 'an MTime containing the new first frame ',
                                                                                          'type': 'MTime'}},
                                                             'args': [('newStartTime',
                                                                       'MTime',
                                                                       'in'),
                                                                      ('newEndTime',
                                                                       'MTime',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSet the values of the first and last frames in the animation.',
                                                             'inArgs': ['newStartTime',
                                                                        'newEndTime'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'newEndTime': [],
                                                                                'newStartTime': []},
                                                             'types': {'newEndTime': 'MTime',
                                                                       'newStartTime': 'MTime'}}],
                               'setAnimationStartTime': [{'argInfo': {'newStartTime': {'doc': 'an MTime containing the new first frame',
                                                                                       'type': 'MTime'}},
                                                          'args': [('newStartTime',
                                                                    'MTime',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSet the value of the first frame in the animation.',
                                                          'inArgs': ['newStartTime'],
                                                          'inverse': ('animationStartTime',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': True,
                                                          'typeQualifiers': {'newStartTime': []},
                                                          'types': {'newStartTime': 'MTime'}}],
                               'setAutoKeyMode': [{'argInfo': {'mode': {'doc': 'a boolean specifying the new mode',
                                                                        'type': 'bool'}},
                                                   'args': [('mode',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the autoKeyMode.',
                                                   'inArgs': ['mode'],
                                                   'inverse': ('autoKeyMode',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'mode': []},
                                                   'types': {'mode': 'bool'}}],
                               'setCurrentTime': [{'argInfo': {'newTime': {'doc': 'an MTime containing the new animation frame',
                                                                           'type': 'MTime'}},
                                                   'args': [('newTime',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the current animation frame.',
                                                   'inArgs': ['newTime'],
                                                   'inverse': ('currentTime',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'newTime': ['const',
                                                                                  '&']},
                                                   'types': {'newTime': 'MTime'}}],
                               'setGlobalInTangentType': [{'argInfo': {'tangentType': {'doc': 'the global in tangent type to set [Note: MFnAnimCurve::kTangentGlobal and MFnAnimCurve::kTangentFixed are not valid arguments]',
                                                                                       'type': ('MFnAnimCurve',
                                                                                                'TangentType')}},
                                                           'args': [('tangentType',
                                                                     ('MFnAnimCurve',
                                                                      'TangentType'),
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSet the current global in tangent type.',
                                                           'inArgs': ['tangentType'],
                                                           'inverse': ('globalInTangentType',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': True,
                                                           'typeQualifiers': {'tangentType': ['const',
                                                                                              '&']},
                                                           'types': {'tangentType': ('MFnAnimCurve',
                                                                                     'TangentType')}}],
                               'setGlobalOutTangentType': [{'argInfo': {'tangentType': {'doc': 'the global out tangent type to set [Note: MFnAnimCurve::kTangentGlobal and MFnAnimCurve::kTangentFixed are not valid arguments]',
                                                                                        'type': ('MFnAnimCurve',
                                                                                                 'TangentType')}},
                                                            'args': [('tangentType',
                                                                      ('MFnAnimCurve',
                                                                       'TangentType'),
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSet the current global out tangent type.',
                                                            'inArgs': ['tangentType'],
                                                            'inverse': ('globalOutTangentType',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': True,
                                                            'typeQualifiers': {'tangentType': ['const',
                                                                                               '&']},
                                                            'types': {'tangentType': ('MFnAnimCurve',
                                                                                      'TangentType')}}],
                               'setMaxTime': [{'argInfo': {'newMaxTime': {'doc': 'an MTime containing the new frame',
                                                                          'type': 'MTime'}},
                                               'args': [('newMaxTime',
                                                         'MTime',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the value of the last frame of the current playback time range.',
                                               'inArgs': ['newMaxTime'],
                                               'inverse': ('maxTime',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'newMaxTime': []},
                                               'types': {'newMaxTime': 'MTime'}}],
                               'setMinMaxTime': [{'argInfo': {'max': {'doc': 'an MTime containing the new last frame',
                                                                      'type': 'MTime'},
                                                              'min': {'doc': 'an MTime containing the new first frame ',
                                                                      'type': 'MTime'}},
                                                  'args': [('min',
                                                            'MTime',
                                                            'in'),
                                                           ('max',
                                                            'MTime',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the values of the first and last frames of the playback time range.',
                                                  'inArgs': ['min',
                                                             'max'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {'max': [],
                                                                     'min': []},
                                                  'types': {'max': 'MTime',
                                                            'min': 'MTime'}}],
                               'setMinTime': [{'argInfo': {'newMinTime': {'doc': 'an MTime containing the frame',
                                                                          'type': 'MTime'}},
                                               'args': [('newMinTime',
                                                         'MTime',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the first frame of the current playback time range.',
                                               'inArgs': ['newMinTime'],
                                               'inverse': ('minTime',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'newMinTime': []},
                                               'types': {'newMinTime': 'MTime'}}],
                               'setPlaybackBy': [{'argInfo': {'newTime': {'doc': 'a double containing the new increment',
                                                                          'type': 'double'}},
                                                  'args': [('newTime',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSpecify the increment between times viewed during the playing of the animation.',
                                                  'inArgs': ['newTime'],
                                                  'inverse': ('playbackBy',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {'newTime': ['const',
                                                                                 '&']},
                                                  'types': {'newTime': 'double'}}],
                               'setPlaybackMode': [{'argInfo': {'newMode': {'doc': 'an element of MAnimControl::PlaybackMode',
                                                                            'type': ('MAnimControl',
                                                                                     'PlaybackMode')}},
                                                    'args': [('newMode',
                                                              ('MAnimControl',
                                                               'PlaybackMode'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the current playback mode.',
                                                    'inArgs': ['newMode'],
                                                    'inverse': ('playbackMode',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'newMode': []},
                                                    'types': {'newMode': ('MAnimControl',
                                                                          'PlaybackMode')}}],
                               'setPlaybackSpeed': [{'argInfo': {'newSpeed': {'doc': 'the new speed factor',
                                                                              'type': 'double'}},
                                                     'args': [('newSpeed',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the desired speed factor at which the animation will play back.',
                                                     'inArgs': ['newSpeed'],
                                                     'inverse': ('playbackSpeed',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': True,
                                                     'typeQualifiers': {'newSpeed': []},
                                                     'types': {'newSpeed': 'double'}}],
                               'setViewMode': [{'argInfo': {'newMode': {'doc': 'an element of MAnimControl::PlaybackViewMode',
                                                                        'type': ('MAnimControl',
                                                                                 'PlaybackViewMode')}},
                                                'args': [('newMode',
                                                          ('MAnimControl',
                                                           'PlaybackViewMode'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet the current viewing mode. Controls whether the animation is run in only the active view, or simultaneously in all views.',
                                                'inArgs': ['newMode'],
                                                'inverse': ('viewMode',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'newMode': []},
                                                'types': {'newMode': ('MAnimControl',
                                                                      'PlaybackViewMode')}}],
                               'setWeightedTangents': [{'argInfo': {'weightState': {'doc': 'a boolean specifying whether tangents should be weighted or not',
                                                                                    'type': 'bool'}},
                                                        'args': [('weightState',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets whether or not the tangents on the Anim Curve are weighted. Note: switching a curve from weightedTangents true to false and back to true again will not preserve fixed tangents properly. Use undo instead.',
                                                        'inArgs': ['weightState'],
                                                        'inverse': ('weightedTangents',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'weightState': []},
                                                        'types': {'weightState': 'bool'}}],
                               'stop': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nStop playing the current animation.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'viewMode': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the viewing mode currently in effect.',
                                             'inArgs': [],
                                             'inverse': ('setViewMode',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MAnimControl',
                                                                     'PlaybackViewMode')},
                                             'returnType': ('MAnimControl',
                                                            'PlaybackViewMode'),
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                               'weightedTangents': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nDetermine whether or not the tangents on the Anim Curve are weighted.',
                                                     'inArgs': [],
                                                     'inverse': ('setWeightedTangents',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': ' true the tangents on the Anim Curve are weighted  false the tangents on the Anim Curve are not weighted  ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}]},
                   'pymelEnums': {'PlaybackMode': "Enum('PlaybackMode', [('once', 0), ('kPlaybackOnce', 0), ('loop', 1), ('kPlaybackLoop', 1), ('oscillate', 2), ('kPlaybackOscillate', 2)], multiKeys=True)",
                                  'PlaybackViewMode': "Enum('PlaybackViewMode', [('all', 0), ('kPlaybackViewAll', 0), ('active', 1), ('kPlaybackViewActive', 1)], multiKeys=True)"},
                   'pymelMethods': {'animationEndTime': 'getAnimationEndTime',
                                    'animationStartTime': 'getAnimationStartTime',
                                    'autoKeyMode': 'getAutoKeyMode',
                                    'currentTime': 'getCurrentTime',
                                    'globalInTangentType': 'getGlobalInTangentType',
                                    'globalOutTangentType': 'getGlobalOutTangentType',
                                    'maxTime': 'getMaxTime',
                                    'minTime': 'getMinTime',
                                    'playbackBy': 'getPlaybackBy',
                                    'playbackMode': 'getPlaybackMode',
                                    'playbackSpeed': 'getPlaybackSpeed',
                                    'viewMode': 'getViewMode',
                                    'weightedTangents': 'getWeightedTangents'}},
  'MAnimCurveChange': {'enums': {},
                       'invertibles': [('setInteractive', 'isInteractive')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'isInteractive': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturn the performance hint flag value.',
                                                      'inArgs': [],
                                                      'inverse': ('setInteractive',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                   'redoIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nRedoes all of the Anim Curve edits that this cache previously undid. It is only valid to invoke this method after an undo on this cache.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                   'setInteractive': [{'argInfo': {'value': {'doc': 'the value to set the flag. ',
                                                                             'type': 'bool'}},
                                                       'args': [('value',
                                                                 'bool',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nThe interactive flag is a performance hint. If the flag is set to true new edits will be merged with the key from previous edit. For example if you are dragging the key each drag will be merged so only the last edit of the drag is safed. If the curves have a lot of scattered edit this merge will not scale well, so it is best to to it to false in this case.',
                                                       'inArgs': ['value'],
                                                       'inverse': ('isInteractive',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'value': []},
                                                       'types': {'value': 'bool'}}],
                                   'undoIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nUndoes all of the Anim Curve edits that have been given to this cache.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                       'pymelEnums': {}},
  'MAnimCurveClipboard': {'enums': {},
                          'methods': {'clear': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method empties the clipboard.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                      'clipboardItems': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns the contents of the clipboard.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The item array currently on this clipboard.',
                                                                         'qualifiers': [],
                                                                         'type': 'MAnimCurveClipboardItemArray'},
                                                          'returnType': 'MAnimCurveClipboardItemArray',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                      'endTime': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the end time of the clipboard.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The end time of the clipboard.',
                                                                  'qualifiers': [],
                                                                  'type': 'MTime'},
                                                   'returnType': 'MTime',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                      'endUnitlessInput': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns the end unitless input of the clipboard.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The end unitless input of the clipboard.',
                                                                           'qualifiers': [],
                                                                           'type': 'float'},
                                                            'returnType': 'float',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                      'isEmpty': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines if the clipboard is empty.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true the current clipboard is empty  false the current clipboard is not empty  Status Code',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                      'set': [{'argInfo': {'cb': {'doc': 'the clipboard to copy',
                                                                  'type': 'MAnimCurveClipboard'}},
                                               'args': [('cb',
                                                         'MAnimCurveClipboard',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReplaces the contents of the clipboard',
                                               'inArgs': ['cb'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'cb': ['const',
                                                                         '&']},
                                               'types': {'cb': 'MAnimCurveClipboard'}},
                                              {'argInfo': {'clipboardItemArray': {'doc': 'the array of clipboard items to load on to the current clipboard',
                                                                                  'type': 'MAnimCurveClipboardItemArray'}},
                                               'args': [('clipboardItemArray',
                                                         'MAnimCurveClipboardItemArray',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets the contents of the clipboard.',
                                               'inArgs': ['clipboardItemArray'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'clipboardItemArray': ['const',
                                                                                         '&']},
                                               'types': {'clipboardItemArray': 'MAnimCurveClipboardItemArray'}},
                                              {'argInfo': {'clipboardItemArray': {'doc': 'the array of clipboard items to load on to the current clipboard ',
                                                                                  'type': 'MAnimCurveClipboardItemArray'},
                                                           'endTime': {'doc': 'the end time for the clipboard ',
                                                                       'type': 'MTime'},
                                                           'endUnitlessInput': {'doc': 'the end unitless input for the clipboard ',
                                                                                'type': 'float'},
                                                           'startTime': {'doc': 'the start time for the clipboard ',
                                                                         'type': 'MTime'},
                                                           'startUnitlessInput': {'doc': 'the start unitless input for the clipboard ',
                                                                                  'type': 'float'},
                                                           'strictValidation': {'doc': "if true, do the validation check, if false, then don't do the check. ",
                                                                                'type': 'bool'}},
                                               'args': [('clipboardItemArray',
                                                         'MAnimCurveClipboardItemArray',
                                                         'in'),
                                                        ('startTime',
                                                         'MTime',
                                                         'in'),
                                                        ('endTime',
                                                         'MTime',
                                                         'in'),
                                                        ('startUnitlessInput',
                                                         'float',
                                                         'out'),
                                                        ('endUnitlessInput',
                                                         'float',
                                                         'out'),
                                                        ('strictValidation',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'strictValidation': True},
                                               'deprecated': False,
                                               'doc': '\r\nSets the contents of the clipboard.',
                                               'inArgs': ['clipboardItemArray',
                                                          'startTime',
                                                          'endTime',
                                                          'strictValidation'],
                                               'outArgs': ['startUnitlessInput',
                                                           'endUnitlessInput'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'clipboardItemArray': ['const',
                                                                                         '&'],
                                                                  'endTime': ['const',
                                                                              '&'],
                                                                  'endUnitlessInput': ['const',
                                                                                       '&'],
                                                                  'startTime': ['const',
                                                                                '&'],
                                                                  'startUnitlessInput': ['const',
                                                                                         '&'],
                                                                  'strictValidation': []},
                                               'types': {'clipboardItemArray': 'MAnimCurveClipboardItemArray',
                                                         'endTime': 'MTime',
                                                         'endUnitlessInput': 'float',
                                                         'startTime': 'MTime',
                                                         'startUnitlessInput': 'float',
                                                         'strictValidation': 'bool'}}],
                                      'startTime': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the start time of the clipboard.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The start time of the clipboard.',
                                                                    'qualifiers': [],
                                                                    'type': 'MTime'},
                                                     'returnType': 'MTime',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                      'startUnitlessInput': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns the start unitless input of the clipboard.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The start unitless input of the clipboard.',
                                                                             'qualifiers': [],
                                                                             'type': 'float'},
                                                              'returnType': 'float',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                      'theAPIClipboard': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns the static API clipboard. \r\n  Reprocessed example  \n Examples: \n \n   \n animFileUtils.cpp , and  animImportExport.cpp . \n \n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['&'],
                                                                          'type': 'MAnimCurveClipboard'},
                                                           'returnType': 'MAnimCurveClipboard',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}]},
                          'pymelEnums': {}},
  'MAnimCurveClipboardItem': {'enums': {},
                              'invertibles': [('setAnimCurve', 'animCurve'),
                                              ('setAddressingInfo',
                                               'getAddressingInfo')],
                              'methods': {'__eq__': [{'argInfo': {'rhs': {'doc': 'The MAnimCurveClipboardItem to be compared against.',
                                                                          'type': 'MAnimCurveClipboardItem'}},
                                                      'args': [('rhs',
                                                                'MAnimCurveClipboardItem',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nCompare the individual members for equality.',
                                                      'inArgs': ['rhs'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': ' true the MAnimCurveClipboard items are equal  false the MAnimCurveClipboard items are not equal   ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'rhs': ['const',
                                                                                 '&']},
                                                      'types': {'rhs': 'MAnimCurveClipboardItem'}}],
                                          'animCurve': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the animCurve held by this clipboard item as an  MObject . Note that the returned  MObject  is const because you must not modify the animCurve referenced by this  MObject .',
                                                         'inArgs': [],
                                                         'inverse': ('setAnimCurve',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'An MObject for the animCurve. On failure, the MObject will be NULL. Be aware that the clipboard may be holding onto NULL animCurves (which are placeholder objects).',
                                                                        'qualifiers': [],
                                                                        'type': 'MObject'},
                                                         'returnType': 'MObject',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                          'animCurveType': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturns the animCurve type',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The animCurve type.',
                                                                            'qualifiers': [],
                                                                            'type': ('MFnAnimCurve',
                                                                                     'AnimCurveType')},
                                                             'returnType': ('MFnAnimCurve',
                                                                            'AnimCurveType'),
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                                             'types': {}}],
                                          'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the name of this class.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'fullAttributeName': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': "\r\nReturns the attribute's full name",
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': "The attribute's full name",
                                                                                'qualifiers': ['&'],
                                                                                'type': 'MString'},
                                                                 'returnType': 'MString',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                                 'types': {}}],
                                          'getAddressingInfo': [{'argInfo': {'attributeCount': {'doc': "The clipboard item's attribute count",
                                                                                                'type': 'uint'},
                                                                             'childCount': {'doc': "The clipboard item's child count ",
                                                                                            'type': 'uint'},
                                                                             'rowCount': {'doc': "The clipboard item's row count ",
                                                                                          'type': 'uint'}},
                                                                 'args': [('rowCount',
                                                                           'uint',
                                                                           'out'),
                                                                          ('childCount',
                                                                           'uint',
                                                                           'out'),
                                                                          ('attributeCount',
                                                                           'uint',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nReturns the addressing information for this clipboard item,',
                                                                 'inArgs': [],
                                                                 'inverse': ('setAddressingInfo',
                                                                             False),
                                                                 'outArgs': ['rowCount',
                                                                             'childCount',
                                                                             'attributeCount'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'attributeCount': ['unsigned',
                                                                                                       '&'],
                                                                                    'childCount': ['unsigned',
                                                                                                   '&'],
                                                                                    'rowCount': ['unsigned',
                                                                                                 '&']},
                                                                 'types': {'attributeCount': 'uint',
                                                                           'childCount': 'uint',
                                                                           'rowCount': 'uint'}}],
                                          'leafAttributeName': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': "\r\nReturns the attribute's leaf name",
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': "The attribute's leaf name.",
                                                                                'qualifiers': ['&'],
                                                                                'type': 'MString'},
                                                                 'returnType': 'MString',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                                 'types': {}}],
                                          'nodeName': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the node name',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The node name.',
                                                                       'qualifiers': ['&'],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                          'setAddressingInfo': [{'argInfo': {'attributeCount': {'doc': "The clipboard item's attribute count",
                                                                                                'type': 'uint'},
                                                                             'childCount': {'doc': "The clipboard item's child count ",
                                                                                            'type': 'uint'},
                                                                             'rowCount': {'doc': "The clipboard item's row count ",
                                                                                          'type': 'uint'}},
                                                                 'args': [('rowCount',
                                                                           'uint',
                                                                           'in'),
                                                                          ('childCount',
                                                                           'uint',
                                                                           'in'),
                                                                          ('attributeCount',
                                                                           'uint',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': "\r\nSets the clipboard item's addressing info",
                                                                 'inArgs': ['rowCount',
                                                                            'childCount',
                                                                            'attributeCount'],
                                                                 'inverse': ('getAddressingInfo',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'attributeCount': ['unsigned'],
                                                                                    'childCount': ['unsigned'],
                                                                                    'rowCount': ['unsigned']},
                                                                 'types': {'attributeCount': 'uint',
                                                                           'childCount': 'uint',
                                                                           'rowCount': 'uint'}}],
                                          'setAnimCurve': [{'argInfo': {'curve': {'doc': 'The animCurve',
                                                                                  'type': 'MObject'}},
                                                            'args': [('curve',
                                                                      'MObject',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': "\r\nSets the clipboard item's animCurve",
                                                            'inArgs': ['curve'],
                                                            'inverse': ('animCurve',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'curve': ['const',
                                                                                         '&']},
                                                            'types': {'curve': 'MObject'}}],
                                          'setNameInfo': [{'argInfo': {'fullName': {'doc': "The clipboard item's full attribute name ",
                                                                                    'type': 'MString'},
                                                                       'leafName': {'doc': "The clipboard item's leaf attribute name",
                                                                                    'type': 'MString'},
                                                                       'nodeName': {'doc': "The clipboard item's node name ",
                                                                                    'type': 'MString'}},
                                                           'args': [('nodeName',
                                                                     'MString',
                                                                     'in'),
                                                                    ('fullName',
                                                                     'MString',
                                                                     'in'),
                                                                    ('leafName',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': "\r\nSets the clipboard item's name info",
                                                           'inArgs': ['nodeName',
                                                                      'fullName',
                                                                      'leafName'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'fullName': ['const',
                                                                                           '&'],
                                                                              'leafName': ['const',
                                                                                           '&'],
                                                                              'nodeName': ['const',
                                                                                           '&']},
                                                           'types': {'fullName': 'MString',
                                                                     'leafName': 'MString',
                                                                     'nodeName': 'MString'}}]},
                              'pymelEnums': {},
                              'pymelMethods': {'animCurve': 'getAnimCurve'}},
  'MAnimCurveClipboardItemArray': {'enums': {},
                                   'invertibles': [('setSizeIncrement',
                                                    'sizeIncrement'),
                                                   ('setLength', 'length')],
                                   'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                                      'type': 'uint'}},
                                                                'args': [('index',
                                                                          'uint',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                                'inArgs': ['index'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                                               'qualifiers': ['&'],
                                                                               'type': 'MAnimCurveClipboardItem'},
                                                                'returnType': 'MAnimCurveClipboardItem',
                                                                'static': False,
                                                                'typeQualifiers': {'index': ['unsigned']},
                                                                'types': {'index': 'uint'}},
                                                               {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                                      'type': 'uint'}},
                                                                'args': [('index',
                                                                          'uint',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                                'inArgs': ['index'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                                               'qualifiers': ['&'],
                                                                               'type': 'MAnimCurveClipboardItem'},
                                                                'returnType': 'MAnimCurveClipboardItem',
                                                                'static': False,
                                                                'typeQualifiers': {'index': ['unsigned']},
                                                                'types': {'index': 'uint'}}],
                                               'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                                   'type': 'MAnimCurveClipboardItem'}},
                                                           'args': [('element',
                                                                     'MAnimCurveClipboardItem',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                                           'inArgs': ['element'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'element': ['const',
                                                                                          '&']},
                                                           'types': {'element': 'MAnimCurveClipboardItem'}}],
                                               'className': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns the name of this class.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': ['*'],
                                                                             'type': 'char'},
                                                              'returnType': 'char',
                                                              'static': True,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                               'clear': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                               'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                                'type': 'MAnimCurveClipboardItemArray'}},
                                                         'args': [('source',
                                                                   'MAnimCurveClipboardItemArray',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nCopy the contents of the source array to this array.',
                                                         'inArgs': ['source'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'source': ['const',
                                                                                       '&']},
                                                         'types': {'source': 'MAnimCurveClipboardItemArray'}}],
                                               'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                                              'type': 'MAnimCurveClipboardItem__array'}},
                                                        'args': [('array',
                                                                  'MAnimCurveClipboardItem__array',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                        'inArgs': ['array'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'array': []},
                                                        'types': {'array': 'MAnimCurveClipboardItem__array'}}],
                                               'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                                   'type': 'MAnimCurveClipboardItem'},
                                                                       'index': {'doc': 'the index of the element to set to the the new value',
                                                                                 'type': 'uint'}},
                                                           'args': [('element',
                                                                     'MAnimCurveClipboardItem',
                                                                     'in'),
                                                                    ('index',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                                           'inArgs': ['element',
                                                                      'index'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'element': ['const',
                                                                                          '&'],
                                                                              'index': ['unsigned']},
                                                           'types': {'element': 'MAnimCurveClipboardItem',
                                                                     'index': 'uint'}}],
                                               'isValid': [{'argInfo': {'failedIndex': {'doc': 'The failed index value',
                                                                                        'type': 'uint'}},
                                                            'args': [('failedIndex',
                                                                      'uint',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nEnsures that the  MAnimCurveClipboard  items in the array make sense.',
                                                            'inArgs': [],
                                                            'outArgs': ['failedIndex'],
                                                            'returnInfo': {'doc': 'true if the clipboard item array is valid, and false otherwise ',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {'failedIndex': ['unsigned',
                                                                                               '&']},
                                                            'types': {'failedIndex': 'uint'}}],
                                               'length': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns the number of elements in the instance.',
                                                           'inArgs': [],
                                                           'inverse': ('setLength',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The number of elements in the instance ',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                               'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                                 'type': 'uint'}},
                                                           'args': [('index',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                                           'inArgs': ['index'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'index': ['unsigned']},
                                                           'types': {'index': 'uint'}}],
                                               'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                                'type': 'MAnimCurveClipboardItem'},
                                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                              'type': 'uint'}},
                                                        'args': [('element',
                                                                  'MAnimCurveClipboardItem',
                                                                  'in'),
                                                                 ('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the value of the indicated element to the indicated  MAnimCurveClipboardItem  value.',
                                                        'inArgs': ['element',
                                                                   'index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'element': ['const',
                                                                                       '&'],
                                                                           'index': ['unsigned']},
                                                        'types': {'element': 'MAnimCurveClipboardItem',
                                                                  'index': 'uint'}}],
                                               'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                                     'type': 'uint'}},
                                                              'args': [('length',
                                                                        'uint',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                                              'inArgs': ['length'],
                                                              'inverse': ('length',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'length': ['unsigned']},
                                                              'types': {'length': 'uint'}}],
                                               'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                                  'type': 'uint'}},
                                                                     'args': [('newIncrement',
                                                                               'uint',
                                                                               'in')],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                                     'inArgs': ['newIncrement'],
                                                                     'inverse': ('sizeIncrement',
                                                                                 True),
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': False,
                                                                     'typeQualifiers': {'newIncrement': ['unsigned']},
                                                                     'types': {'newIncrement': 'uint'}}],
                                               'sizeIncrement': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                                  'inArgs': [],
                                                                  'inverse': ('setSizeIncrement',
                                                                              False),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': 'int'},
                                                                  'returnType': 'int',
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}]},
                                   'pymelEnums': {},
                                   'pymelMethods': {'length': 'getLength',
                                                    'sizeIncrement': 'getSizeIncrement'}},
  'MAnimMessage': {'enums': {},
                   'methods': {'addAnimCurveEditedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function. ',
                                                                                          'type': 'void'},
                                                                           'func': {'doc': 'The callback function.',
                                                                                    'type': ('MMessage',
                                                                                             'MObjArray')}},
                                                               'args': [('func',
                                                                         ('MMessage',
                                                                          'MObjArray'),
                                                                         'in'),
                                                                        ('clientData',
                                                                         'void',
                                                                         'in')],
                                                               'defaults': {'clientData': None},
                                                               'deprecated': False,
                                                               'doc': '\nAnimCurve edited callback. \n',
                                                               'inArgs': ['func',
                                                                          'clientData'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                              'qualifiers': [],
                                                                              'type': 'MCallbackId'},
                                                               'returnType': 'MCallbackId',
                                                               'static': True,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'clientData': ['*'],
                                                                                  'func': []},
                                                               'types': {'clientData': 'void',
                                                                         'func': ('MMessage',
                                                                                  'MObjArray')}}],
                               'addAnimKeyframeEditCheckCallback': [{'argInfo': {'clientData': {'doc': 'User defined data. ',
                                                                                                'type': 'void'},
                                                                                 'func': {'doc': 'the callback function  retCode return code from callback, setting this to false will abort the keyframe action  plug the plug being keyframed  clientData User defined data passed to the callback function   ',
                                                                                          'type': ('MMessage',
                                                                                                   'MCheckPlugFunction')}},
                                                                     'args': [('func',
                                                                               ('MMessage',
                                                                                'MCheckPlugFunction'),
                                                                               'in'),
                                                                              ('clientData',
                                                                               'void',
                                                                               'in')],
                                                                     'defaults': {'clientData': None},
                                                                     'deprecated': False,
                                                                     'doc': '\nAnimCurve keyframe edit check callback. \n',
                                                                     'inArgs': ['func',
                                                                                'clientData'],
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                    'qualifiers': [],
                                                                                    'type': 'MCallbackId'},
                                                                     'returnType': 'MCallbackId',
                                                                     'static': True,
                                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                        'clientData': ['*'],
                                                                                        'func': []},
                                                                     'types': {'clientData': 'void',
                                                                               'func': ('MMessage',
                                                                                        'MCheckPlugFunction')}}],
                               'addAnimKeyframeEditedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data. ',
                                                                                             'type': 'void'},
                                                                              'func': {'doc': 'the callback function',
                                                                                       'type': ('MMessage',
                                                                                                'MObjArray')}},
                                                                  'args': [('func',
                                                                            ('MMessage',
                                                                             'MObjArray'),
                                                                            'in'),
                                                                           ('clientData',
                                                                            'void',
                                                                            'in')],
                                                                  'defaults': {'clientData': None},
                                                                  'deprecated': False,
                                                                  'doc': '\nAnimCurve keyframe edited callback. \n',
                                                                  'inArgs': ['func',
                                                                             'clientData'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'MCallbackId'},
                                                                  'returnType': 'MCallbackId',
                                                                  'static': True,
                                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                     'clientData': ['*'],
                                                                                     'func': []},
                                                                  'types': {'clientData': 'void',
                                                                            'func': ('MMessage',
                                                                                     'MObjArray')}}],
                               'addDisableImplicitControlCallback': [{'argInfo': {'clientData': {'doc': 'User defined data. ',
                                                                                                 'type': 'void'},
                                                                                  'func': {'doc': 'the callback function  plugArray the baked plugs.  modifier the DGModifier. Used if bakeResults command is undone or redone.  clientData User defined data passed to the callback function   ',
                                                                                           'type': ('MMessage',
                                                                                                    'MPlugsDGModFunction')}},
                                                                      'args': [('func',
                                                                                ('MMessage',
                                                                                 'MPlugsDGModFunction'),
                                                                                'out'),
                                                                               ('clientData',
                                                                                'void',
                                                                                'in')],
                                                                      'defaults': {'clientData': None},
                                                                      'deprecated': False,
                                                                      'doc': '\nDisable Implicit Control callback. \n',
                                                                      'inArgs': ['clientData'],
                                                                      'outArgs': ['func'],
                                                                      'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                     'qualifiers': [],
                                                                                     'type': 'MCallbackId'},
                                                                      'returnType': 'MCallbackId',
                                                                      'static': True,
                                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                         'clientData': ['*'],
                                                                                         'func': []},
                                                                      'types': {'clientData': 'void',
                                                                                'func': ('MMessage',
                                                                                         'MPlugsDGModFunction')}}],
                               'addNodeAnimKeyframeEditedCallback': [{'argInfo': {'animNode': {'doc': 'the param curve node you want to watch. ',
                                                                                               'type': 'MObject'},
                                                                                  'clientData': {'doc': 'User defined data. ',
                                                                                                 'type': 'void'},
                                                                                  'func': {'doc': 'the callback function',
                                                                                           'type': ('MMessage',
                                                                                                    'MNodeObjArray')}},
                                                                      'args': [('animNode',
                                                                                'MObject',
                                                                                'in'),
                                                                               ('func',
                                                                                ('MMessage',
                                                                                 'MNodeObjArray'),
                                                                                'in'),
                                                                               ('clientData',
                                                                                'void',
                                                                                'in')],
                                                                      'defaults': {'clientData': None},
                                                                      'deprecated': False,
                                                                      'doc': '\nAnimCurve keyframe edited callback. \n',
                                                                      'inArgs': ['animNode',
                                                                                 'func',
                                                                                 'clientData'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                     'qualifiers': [],
                                                                                     'type': 'MCallbackId'},
                                                                      'returnType': 'MCallbackId',
                                                                      'static': True,
                                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                         'animNode': ['&'],
                                                                                         'clientData': ['*'],
                                                                                         'func': []},
                                                                      'types': {'animNode': 'MObject',
                                                                                'clientData': 'void',
                                                                                'func': ('MMessage',
                                                                                         'MNodeObjArray')}}],
                               'addPostBakeResultsCallback': [{'argInfo': {'clientData': {'doc': 'User defined data. ',
                                                                                          'type': 'void'},
                                                                           'func': {'doc': 'the callback function  plugArray the baked plugs to which the resulting anim curves will be connected. The plugs can be replaced, but must have the same number of plugs.  modifier the DGModifier. Used if bakeResults command is undone or redone.  clientData User defined data passed to the callback function   ',
                                                                                    'type': ('MMessage',
                                                                                             'MPlugsDGModFunction')}},
                                                               'args': [('func',
                                                                         ('MMessage',
                                                                          'MPlugsDGModFunction'),
                                                                         'out'),
                                                                        ('clientData',
                                                                         'void',
                                                                         'in')],
                                                               'defaults': {'clientData': None},
                                                               'deprecated': False,
                                                               'doc': '\nPost Bake Simulation callback. \n',
                                                               'inArgs': ['clientData'],
                                                               'outArgs': ['func'],
                                                               'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                              'qualifiers': [],
                                                                              'type': 'MCallbackId'},
                                                               'returnType': 'MCallbackId',
                                                               'static': True,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'clientData': ['*'],
                                                                                  'func': []},
                                                               'types': {'clientData': 'void',
                                                                         'func': ('MMessage',
                                                                                  'MPlugsDGModFunction')}}],
                               'addPreBakeResultsCallback': [{'argInfo': {'clientData': {'doc': 'User defined data. ',
                                                                                         'type': 'void'},
                                                                          'func': {'doc': 'the callback function  plugArray the plugs to be baked. The plugs can be replaced, but must have the same number of plugs.  modifier the DGModifier. Used if bakeResults command is undone or redone.  clientData User defined data passed to the callback function   ',
                                                                                   'type': ('MMessage',
                                                                                            'MPlugsDGModFunction')}},
                                                              'args': [('func',
                                                                        ('MMessage',
                                                                         'MPlugsDGModFunction'),
                                                                        'out'),
                                                                       ('clientData',
                                                                        'void',
                                                                        'in')],
                                                              'defaults': {'clientData': None},
                                                              'deprecated': False,
                                                              'doc': '\nPre Bake Simulation callback. \n',
                                                              'inArgs': ['clientData'],
                                                              'outArgs': ['func'],
                                                              'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                             'qualifiers': [],
                                                                             'type': 'MCallbackId'},
                                                              'returnType': 'MCallbackId',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'clientData': ['*'],
                                                                                 'func': []},
                                                              'types': {'clientData': 'void',
                                                                        'func': ('MMessage',
                                                                                 'MPlugsDGModFunction')}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'flushAnimKeyframeEditedCallbacks': [{'argInfo': {},
                                                                     'args': [],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': '\nAnimCurve keyframe edited callback flush. \n',
                                                                     'inArgs': [],
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': True,
                                                                     'typeQualifiers': {},
                                                                     'types': {}}]},
                   'pymelEnums': {}},
  'MAnimUtil': {'enums': {},
                'methods': {'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'findAnimatablePlugs': [{'argInfo': {'animatablePlugs': {'doc': 'the list of attributes which are animatable the array is not cleared',
                                                                                     'type': 'MPlugArray'},
                                                                 'selectionList': {'doc': 'the MSelectionList to examine ',
                                                                                   'type': 'MSelectionList'}},
                                                     'args': [('selectionList',
                                                               'MSelectionList',
                                                               'in'),
                                                              ('animatablePlugs',
                                                               'MPlugArray',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nFind the list of attributes (MPlugs) on any member of an  MSelectionList  that is animatable.',
                                                     'inArgs': ['selectionList',
                                                                'animatablePlugs'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': ' true The MSelectionList has at least one animatable member.  false No member of the MSelectionList is animatable.   ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {'animatablePlugs': ['&'],
                                                                        'selectionList': ['const',
                                                                                          '&']},
                                                     'types': {'animatablePlugs': 'MPlugArray',
                                                               'selectionList': 'MSelectionList'}}],
                            'findAnimatedPlugs': [{'argInfo': {'animatedPlugs': {'doc': 'the list of attributes which are animated the array is not cleared ',
                                                                                 'type': 'MPlugArray'},
                                                               'checkParent': {'doc': "whether or not to examine if the node's parent is animated ",
                                                                               'type': 'bool'},
                                                               'node': {'doc': 'the MObject to examine ',
                                                                        'type': 'MObject'}},
                                                   'args': [('node',
                                                             'MObject',
                                                             'in'),
                                                            ('animatedPlugs',
                                                             'MPlugArray',
                                                             'in'),
                                                            ('checkParent',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'checkParent': False},
                                                   'deprecated': False,
                                                   'doc': "\r\nFind the list of attributes (MPlugs) on an  MObject  that is animated. If the  MObject  is a hierarchical object (such as a dag node) then you may also specify whether or not the MObject's parents are examined. In the case of instanced MObjects, all of the MObject's parents are examined.",
                                                   'inArgs': ['node',
                                                              'animatedPlugs',
                                                              'checkParent'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true The MObject is animated.  false The MObject is not animated.   ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'animatedPlugs': ['&'],
                                                                      'checkParent': [],
                                                                      'node': ['const',
                                                                               '&']},
                                                   'types': {'animatedPlugs': 'MPlugArray',
                                                             'checkParent': 'bool',
                                                             'node': 'MObject'}},
                                                  {'argInfo': {'animatedPlugs': {'doc': 'the list of attributes which are animated the array is not cleared ',
                                                                                 'type': 'MPlugArray'},
                                                               'checkParent': {'doc': "whether or not to examine if the path's parent is animated ",
                                                                               'type': 'bool'},
                                                               'path': {'doc': 'the MDagPath to examine ',
                                                                        'type': 'MDagPath'}},
                                                   'args': [('path',
                                                             'MDagPath',
                                                             'in'),
                                                            ('animatedPlugs',
                                                             'MPlugArray',
                                                             'in'),
                                                            ('checkParent',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'checkParent': False},
                                                   'deprecated': False,
                                                   'doc': "\r\nFind the list of attributes (MPlugs) on an  MDagPath  object that is animated. You may also specify whether or not the MDagPath's parent is examined. In the case of instanced  MDagPath  only the specified path is examined.",
                                                   'inArgs': ['path',
                                                              'animatedPlugs',
                                                              'checkParent'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true The MDagPath is animated.  false The MDagPath is not animated.   ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'animatedPlugs': ['&'],
                                                                      'checkParent': [],
                                                                      'path': ['const',
                                                                               '&']},
                                                   'types': {'animatedPlugs': 'MPlugArray',
                                                             'checkParent': 'bool',
                                                             'path': 'MDagPath'}},
                                                  {'argInfo': {'animatedPlugs': {'doc': 'the list of attributes which are animated the array is not cleared ',
                                                                                 'type': 'MPlugArray'},
                                                               'checkParent': {'doc': "whether or not to examine if the node's parent is animated ",
                                                                               'type': 'bool'},
                                                               'selectionList': {'doc': 'the MSelectionList to examine ',
                                                                                 'type': 'MSelectionList'}},
                                                   'args': [('selectionList',
                                                             'MSelectionList',
                                                             'in'),
                                                            ('animatedPlugs',
                                                             'MPlugArray',
                                                             'in'),
                                                            ('checkParent',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'checkParent': False},
                                                   'deprecated': False,
                                                   'doc': '\r\nFind the list of attributes (MPlugs) on any member of an  MSelectionList  that is animated.',
                                                   'inArgs': ['selectionList',
                                                              'animatedPlugs',
                                                              'checkParent'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true The MSelectionList has at least one animated member.  false No member of the MSelectionList is animated.   ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'animatedPlugs': ['&'],
                                                                      'checkParent': [],
                                                                      'selectionList': ['const',
                                                                                        '&']},
                                                   'types': {'animatedPlugs': 'MPlugArray',
                                                             'checkParent': 'bool',
                                                             'selectionList': 'MSelectionList'}}],
                            'findAnimation': [{'argInfo': {'animation': {'doc': "the list of animCurves which animate `plug'. The array is not cleared ",
                                                                         'type': 'MObjectArray'},
                                                           'plug': {'doc': 'the plug to examine for animCurve(s) ',
                                                                    'type': 'MPlug'}},
                                               'args': [('plug',
                                                         'MPlug',
                                                         'in'),
                                                        ('animation',
                                                         'MObjectArray',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFind the animCurve(s) that are animating a given attribute ( MPlug ). In most cases an attribute is animated by a single animCurve and so just that animCurve will be returned. It is possible to setup a series of connections where an attribute is animated by more than one animCurve, although Maya does not currently offer a UI to do so. Compound attributes are not expanded to include any child attributes.',
                                               'inArgs': ['plug',
                                                          'animation'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': ' true The MPlug is animated.  false The MPlug is not animated.   ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'animation': ['&'],
                                                                  'plug': ['const',
                                                                           '&']},
                                               'types': {'animation': 'MObjectArray',
                                                         'plug': 'MPlug'}}],
                            'findConstraint': [{'argInfo': {'constraint': {'doc': 'the constraint ',
                                                                           'type': 'MObject'},
                                                            'plug': {'doc': 'the plug to examine for a constraint ',
                                                                     'type': 'MPlug'},
                                                            'targets': {'doc': 'the list of constraint targets The array is not cleared. ',
                                                                        'type': 'MObjectArray'}},
                                                'args': [('plug',
                                                          'MPlug',
                                                          'in'),
                                                         ('constraint',
                                                          'MObject',
                                                          'out'),
                                                         ('targets',
                                                          'MObjectArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nFind any constraint that is directly driving the specified attribute. If a constraint is found, this method will also find the constraint targets. Return false if no constraint exists on the attribute.',
                                                'inArgs': ['plug'],
                                                'outArgs': ['constraint',
                                                            'targets'],
                                                'returnInfo': {'doc': ' true The MPlug is controlled by a constraint  false The MPlug is not animated by a constraint   ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'constraint': ['&'],
                                                                   'plug': ['const',
                                                                            '&'],
                                                                   'targets': ['&']},
                                                'types': {'constraint': 'MObject',
                                                          'plug': 'MPlug',
                                                          'targets': 'MObjectArray'}}],
                            'findSetDrivenKeyAnimation': [{'argInfo': {'animationNodes': {'doc': "the list of sdk animation curves and a blendWeighted node that drive the `plug'. The array is not cleared ",
                                                                                          'type': 'MObjectArray'},
                                                                       'drivers': {'doc': 'the list of driver attribute(s). The array is not cleared. ',
                                                                                   'type': 'MPlugArray'},
                                                                       'plug': {'doc': 'the plug to examine for animCurve(s) ',
                                                                                'type': 'MPlug'}},
                                                           'args': [('plug',
                                                                     'MPlug',
                                                                     'in'),
                                                                    ('animationNodes',
                                                                     'MObjectArray',
                                                                     'out'),
                                                                    ('drivers',
                                                                     'MPlugArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nFind any driven keyframe animCurves, the blendWeighted node and the driver attribute(s) that are animating a given attribute ( MPlug ). Or return false if no driven keyframe exists on the attribute.',
                                                           'inArgs': ['plug'],
                                                           'outArgs': ['animationNodes',
                                                                       'drivers'],
                                                           'returnInfo': {'doc': ' true The MPlug is animated by a setDrivenKey.  false The MPlug is not animated by a setDrivenKey.   ',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'animationNodes': ['&'],
                                                                              'drivers': ['&'],
                                                                              'plug': ['const',
                                                                                       '&']},
                                                           'types': {'animationNodes': 'MObjectArray',
                                                                     'drivers': 'MPlugArray',
                                                                     'plug': 'MPlug'}}],
                            'isAnimated': [{'argInfo': {'checkParent': {'doc': "whether or not to examine if the node's parent is animated ",
                                                                        'type': 'bool'},
                                                        'node': {'doc': 'the MObject to examine ',
                                                                 'type': 'MObject'}},
                                            'args': [('node',
                                                      'MObject',
                                                      'in'),
                                                     ('checkParent',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'checkParent': False},
                                            'deprecated': False,
                                            'doc': "\r\nDetermine whether or not an  MObject  is animated. If the  MObject  is a hierarchical object (such as a dag node) then you may also specify whether or not the MObject's parents are examined. In the case of instanced MObjects, all of the MObject's parents are examined.",
                                            'inArgs': ['node',
                                                       'checkParent'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true The MObject is animated.  false The MObject is not animated.   ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': True,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'checkParent': [],
                                                               'node': ['const',
                                                                        '&']},
                                            'types': {'checkParent': 'bool',
                                                      'node': 'MObject'}},
                                           {'argInfo': {'checkParent': {'doc': "whether or not to examine if the path's parent is animated ",
                                                                        'type': 'bool'},
                                                        'path': {'doc': 'the MDagPath to examine ',
                                                                 'type': 'MDagPath'}},
                                            'args': [('path',
                                                      'MDagPath',
                                                      'in'),
                                                     ('checkParent',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'checkParent': False},
                                            'deprecated': False,
                                            'doc': "\r\nDetermine whether or not an  MDagPath  is animated. You may also specify whether or not the MDagPath's parent is examined. In the case of instanced  MDagPath  only the specified path is examined.",
                                            'inArgs': ['path',
                                                       'checkParent'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true The MDagPath is animated.  false The MDagPath is not animated.   ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': True,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'checkParent': [],
                                                               'path': ['const',
                                                                        '&']},
                                            'types': {'checkParent': 'bool',
                                                      'path': 'MDagPath'}},
                                           {'argInfo': {'checkParent': {'doc': "whether or not to examine if the node's parent is animated ",
                                                                        'type': 'bool'},
                                                        'plug': {'doc': 'the MPlug to examine ',
                                                                 'type': 'MPlug'}},
                                            'args': [('plug',
                                                      'MPlug',
                                                      'in'),
                                                     ('checkParent',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'checkParent': False},
                                            'deprecated': False,
                                            'doc': "\r\nDetermine whether or not an  MPlug  is animated. If the  MPlug  does not have an attribute specified, then the entire node is examined. You may also specify whether or not the node's parents are examined. In the case of instanced nodes, all of the node's parents are examined. If an attribute has been specified, the node's parents are not examined.",
                                            'inArgs': ['plug',
                                                       'checkParent'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true The MPlug is animated.  false The MPlug is not animated.   ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': True,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'checkParent': [],
                                                               'plug': ['const',
                                                                        '&']},
                                            'types': {'checkParent': 'bool',
                                                      'plug': 'MPlug'}},
                                           {'argInfo': {'checkParent': {'doc': "whether or not to examine if the node's parent is animated ",
                                                                        'type': 'bool'},
                                                        'selectionList': {'doc': 'the MSelectionList to examine ',
                                                                          'type': 'MSelectionList'}},
                                            'args': [('selectionList',
                                                      'MSelectionList',
                                                      'in'),
                                                     ('checkParent',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'checkParent': False},
                                            'deprecated': False,
                                            'doc': '\r\nDetermine whether or not any member of an  MSelectionList  is animated. This is intended to work with an  MSelectionList  with a single entry since that provides the most useful information.',
                                            'inArgs': ['selectionList',
                                                       'checkParent'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true The MSelectionList has at least one animated member.  false No member of the MSelectionList is animated.   ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': True,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'checkParent': [],
                                                               'selectionList': ['const',
                                                                                 '&']},
                                            'types': {'checkParent': 'bool',
                                                      'selectionList': 'MSelectionList'}}]},
                'pymelEnums': {}},
  'MArgDatabase': {'enums': {},
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'getCommandArgument': [{'argInfo': {'index': {'doc': 'index of the command argument ',
                                                                             'type': 'uint'},
                                                                   'result': {'doc': 'value of the argument as an MSelectionList',
                                                                              'type': 'MSelectionList'}},
                                                       'args': [('index',
                                                                 'uint',
                                                                 'in'),
                                                                ('result',
                                                                 'MSelectionList',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGets the value of the requested command argument and appends it to the end of the  MSelectionList  that is passed in.',
                                                       'inArgs': ['index'],
                                                       'outArgs': ['result'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'index': ['unsigned'],
                                                                          'result': ['&']},
                                                       'types': {'index': 'uint',
                                                                 'result': 'MSelectionList'}}],
                               'getFlagArgument': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                         'type': 'char'},
                                                                'index': {'doc': 'index of the parameter ',
                                                                          'type': 'uint'},
                                                                'result': {'doc': 'value of the parameter as an MSelectionList',
                                                                           'type': 'MSelectionList'}},
                                                    'args': [('flag',
                                                              'char',
                                                              'in'),
                                                             ('index',
                                                              'uint',
                                                              'in'),
                                                             ('result',
                                                              'MSelectionList',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MSelectionList .",
                                                    'inArgs': ['flag',
                                                               'index'],
                                                    'outArgs': ['result'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'flag': ['const',
                                                                                '*'],
                                                                       'index': ['unsigned'],
                                                                       'result': ['&']},
                                                    'types': {'flag': 'char',
                                                              'index': 'uint',
                                                              'result': 'MSelectionList'}}],
                               'getObjects': [{'argInfo': {'result': {'doc': 'list of objects passed to the command',
                                                                      'type': 'MSelectionList'}},
                                               'args': [('result',
                                                         'MSelectionList',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGets the list of objects passed to the command as an  MSelectionList .',
                                               'inArgs': [],
                                               'outArgs': ['result'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'result': ['&']},
                                               'types': {'result': 'MSelectionList'}},
                                              {'argInfo': {'result': {'doc': 'the list of objects passed to the command as an MStringArray',
                                                                      'type': 'MStringArray'}},
                                               'args': [('result',
                                                         'MStringArray',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGets the list of objects passed to the command as an array of strings.',
                                               'inArgs': [],
                                               'outArgs': ['result'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'result': ['&']},
                                               'types': {'result': 'MStringArray'}}]},
                   'pymelEnums': {}},
  'MArgList': {'enums': {},
               'methods': {'addArg': [{'argInfo': {'arg': {'doc': 'the new bool argument',
                                                           'type': 'bool'}},
                                       'args': [('arg', 'bool', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new bool argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': []},
                                       'types': {'arg': 'bool'}},
                                      {'argInfo': {'arg': {'doc': 'the new integer argument',
                                                           'type': 'int'}},
                                       'args': [('arg', 'int', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new integer argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': []},
                                       'types': {'arg': 'int'}},
                                      {'argInfo': {'arg': {'doc': 'the new double argument',
                                                           'type': 'double'}},
                                       'args': [('arg', 'double', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new double argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': []},
                                       'types': {'arg': 'double'}},
                                      {'argInfo': {'arg': {'doc': 'the new MString argument',
                                                           'type': 'MString'}},
                                       'args': [('arg', 'MString', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new  MString  argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': ['const',
                                                                  '&']},
                                       'types': {'arg': 'MString'}},
                                      {'argInfo': {'arg': {'doc': 'the new MDistance argument',
                                                           'type': 'MDistance'}},
                                       'args': [('arg',
                                                 'MDistance',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new  MDistance  argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': ['const',
                                                                  '&']},
                                       'types': {'arg': 'MDistance'}},
                                      {'argInfo': {'arg': {'doc': 'the new MAngle argument',
                                                           'type': 'MAngle'}},
                                       'args': [('arg', 'MAngle', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new  MAngle  argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': ['const',
                                                                  '&']},
                                       'types': {'arg': 'MAngle'}},
                                      {'argInfo': {'arg': {'doc': 'the new MTime argument',
                                                           'type': 'MTime'}},
                                       'args': [('arg', 'MTime', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new  MTime  argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': ['const',
                                                                  '&']},
                                       'types': {'arg': 'MTime'}},
                                      {'argInfo': {'arg': {'doc': 'the new MVector argument',
                                                           'type': 'MVector'}},
                                       'args': [('arg', 'MVector', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new  MVector  argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': ['const',
                                                                  '&']},
                                       'types': {'arg': 'MVector'}},
                                      {'argInfo': {'arg': {'doc': 'the new MPoint argument',
                                                           'type': 'MPoint'}},
                                       'args': [('arg', 'MPoint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdd a new  MPoint  argument to the arglist.',
                                       'inArgs': ['arg'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'arg': ['const',
                                                                  '&']},
                                       'types': {'arg': 'MPoint'}}],
                           'asAngle': [{'argInfo': {'index': {'doc': 'the index of the desired argument ',
                                                              'type': 'uint'}},
                                        'args': [('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturn the value of the argument at a given position in the arglist as an  MAngle .',
                                        'inArgs': ['index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The MAngle value of the indicated argument.',
                                                       'qualifiers': [],
                                                       'type': 'MAngle'},
                                        'returnType': 'MAngle',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           'index': ['unsigned']},
                                        'types': {'index': 'uint'}}],
                           'asBool': [{'argInfo': {'index': {'doc': 'the index of the desired argument ',
                                                             'type': 'uint'}},
                                       'args': [('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturn the value of the argument at a given position in the arglist as an bool.',
                                       'inArgs': ['index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The bool value of the indicated argument.',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                          'index': ['unsigned']},
                                       'types': {'index': 'uint'}}],
                           'asDistance': [{'argInfo': {'index': {'doc': 'the index of the desired argument ',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the value of the argument at a given position in the arglist as an  MDistance .',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The MDistance value of the indicated argument.',
                                                          'qualifiers': [],
                                                          'type': 'MDistance'},
                                           'returnType': 'MDistance',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'index': ['unsigned']},
                                           'types': {'index': 'uint'}}],
                           'asDouble': [{'argInfo': {'index': {'doc': 'the index of the desired argument ',
                                                               'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the value of the argument at a given position in the arglist as a double.',
                                         'inArgs': ['index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The double value of the indicated argument.',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': ['unsigned']},
                                         'types': {'index': 'uint'}}],
                           'asDoubleArray': [{'argInfo': {'index': {'doc': 'index of the first argument to be used in building the array. That argument will be taken as an integer count of the number of array elements which follow it. On success the index will be updated to point to the argument for the last array element (i.e. incremented by the number of elements). On failure it will be updated to point to the argument where the failure occurred. ',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the value of the  MDoubleArray  argument at a given position in the arglist.',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'MDoubleArray ',
                                                             'qualifiers': [],
                                                             'type': 'MDoubleArray'},
                                              'returnType': 'MDoubleArray',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'index': ['unsigned',
                                                                           '&']},
                                              'types': {'index': 'uint'}}],
                           'asInt': [{'argInfo': {'index': {'doc': 'the index of the desired argument ',
                                                            'type': 'uint'}},
                                      'args': [('index', 'uint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn the value of the argument at a given position in the arglist as an integer.',
                                      'inArgs': ['index'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The integer value of the indicated argument.',
                                                     'qualifiers': [],
                                                     'type': 'int'},
                                      'returnType': 'int',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'index': ['unsigned']},
                                      'types': {'index': 'uint'}}],
                           'asIntArray': [{'argInfo': {'index': {'doc': 'index of the first argument to be used in building the array. That argument will be taken as an integer count of the number of array elements which follow it. On success the index will be updated to point to the argument for the last array element (i.e. incremented by the number of elements). On failure it will be updated to point to the argument where the failure occurred. ',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nGet the value of the  MIntArray  argument at a given position in the arglist.',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MIntArray ',
                                                          'qualifiers': [],
                                                          'type': 'MIntArray'},
                                           'returnType': 'MIntArray',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'index': ['unsigned',
                                                                        '&']},
                                           'types': {'index': 'uint'}}],
                           'asMatrix': [{'argInfo': {'index': {'doc': 'index of the first argument to be used in building the matrix. On success it will be updated to point to the last argument used to build the matrix (i.e. it will be incremented by 15). On failure it will be updated to point to the argument where the failure occurred. ',
                                                               'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nGet the value of the  MMatrix  argument at a given position in the arglist.',
                                         'inArgs': ['index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The MMatrix value of the indicated argument.',
                                                        'qualifiers': [],
                                                        'type': 'MMatrix'},
                                         'returnType': 'MMatrix',
                                         'static': False,
                                         'typeQualifiers': {'index': ['unsigned',
                                                                      '&'],
                                                            'ret': ['*']},
                                         'types': {'index': 'uint'}}],
                           'asPoint': [{'argInfo': {'index': {'doc': 'index of the first argument to be used as an element of the point. On success it will be updated to point to the last argument used to build the point (i.e. incremented by numElements-1). On failure it will be updated to point to the argument where the failure occurred. ',
                                                              'type': 'uint'},
                                                    'numElements': {'doc': 'dimension of the point to be returned. This should not exceed 4, which is the maximum number of dimensions that an MPoint can hold. ',
                                                                    'type': 'uint'}},
                                        'args': [('index', 'uint', 'in'),
                                                 ('numElements',
                                                  'uint',
                                                  'in')],
                                        'defaults': {'numElements': 3},
                                        'deprecated': False,
                                        'doc': '\r\nReturn the value of the argument at a given position in the arglist as an  MPoint .',
                                        'inArgs': ['index',
                                                   'numElements'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The MPoint value of the indicated argument.',
                                                       'qualifiers': [],
                                                       'type': 'MPoint'},
                                        'returnType': 'MPoint',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           'index': ['unsigned',
                                                                     '&'],
                                                           'numElements': ['unsigned']},
                                        'types': {'index': 'uint',
                                                  'numElements': 'uint'}}],
                           'asString': [{'argInfo': {'index': {'doc': 'the index of the desired argument ',
                                                               'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the value of the argument at a given position in the arglist as an  MString .',
                                         'inArgs': ['index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The MString value of the indicated argument.',
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': ['unsigned']},
                                         'types': {'index': 'uint'}}],
                           'asStringArray': [{'argInfo': {'index': {'doc': 'index of the first argument to be used in building the array. That argument will be taken as an integer count of the number of array elements which follow it. On success the index will be updated to point to the argument for the last array element (i.e. incremented by the number of elements). On failure it will be updated to point to the argument where the failure occurred. ',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the value of the  MStringArray  argument at a given position in the arglist.',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'MStringArray ',
                                                             'qualifiers': [],
                                                             'type': 'MStringArray'},
                                              'returnType': 'MStringArray',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'index': ['unsigned',
                                                                           '&']},
                                              'types': {'index': 'uint'}}],
                           'asTime': [{'argInfo': {'index': {'doc': 'the index of the desired argument ',
                                                             'type': 'uint'}},
                                       'args': [('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturn the value of the argument at a given position in the arglist as an  MTime .',
                                       'inArgs': ['index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The MTime value of the indicated argument.',
                                                      'qualifiers': [],
                                                      'type': 'MTime'},
                                       'returnType': 'MTime',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                          'index': ['unsigned']},
                                       'types': {'index': 'uint'}}],
                           'asVector': [{'argInfo': {'index': {'doc': 'index of the first argument to be used as an element of the vector. On success it will be updated to point to the last argument used to build the vector (i.e. incremented by numElements-1). On failure it will be updated to point to the argument where the failure occurred. ',
                                                               'type': 'uint'},
                                                     'numElements': {'doc': 'dimension of the vector to be returned. This should not exceed 3, which is the maximum number of dimensions that an MVector can hold. ',
                                                                     'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in'),
                                                  ('numElements',
                                                   'uint',
                                                   'in')],
                                         'defaults': {'numElements': 3},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the value of the argument at a given position in the arglist as an  MVector .',
                                         'inArgs': ['index',
                                                    'numElements'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The MVector value of the indicated argument.',
                                                        'qualifiers': [],
                                                        'type': 'MVector'},
                                         'returnType': 'MVector',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': ['unsigned',
                                                                      '&'],
                                                            'numElements': ['unsigned']},
                                         'types': {'index': 'uint',
                                                   'numElements': 'uint'}}],
                           'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'flagIndex': [{'argInfo': {'longFlag': {'doc': 'the int version of the flag (if any)',
                                                                   'type': 'char'},
                                                      'shortFlag': {'doc': 'the short version of the flag ',
                                                                    'type': 'char'}},
                                          'args': [('shortFlag',
                                                    'char',
                                                    'in'),
                                                   ('longFlag',
                                                    'char',
                                                    'in')],
                                          'defaults': {'longFlag': None},
                                          'deprecated': False,
                                          'doc': '\r\nReturn the index entry of the requested flag, if it has been set.',
                                          'inArgs': ['shortFlag',
                                                     'longFlag'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The unsigned int index of the indicated argument if it has been set, kInvalidArgIndex otherwise. ',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {'longFlag': ['const',
                                                                          '*'],
                                                             'shortFlag': ['const',
                                                                           '*']},
                                          'types': {'longFlag': 'char',
                                                    'shortFlag': 'char'}}],
                           'length': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns the number of arguments in the arglist.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The number of arguments in the arglist.',
                                                      'qualifiers': [],
                                                      'type': 'int'},
                                       'returnType': 'int',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}]},
               'pymelEnums': {}},
  'MArgParser': {'enums': {},
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'commandArgumentBool': [{'argInfo': {'index': {'doc': 'the index of the argument to the command ',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the value of the requested command argument as a boolean.',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The value of the argument as a boolean',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                             'commandArgumentDouble': [{'argInfo': {'index': {'doc': 'the index of the argument to the command ',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGets the value of the requested command argument as a double.',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the argument as a double',
                                                                       'qualifiers': [],
                                                                       'type': 'double'},
                                                        'returnType': 'double',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'index': ['unsigned']},
                                                        'types': {'index': 'uint'}}],
                             'commandArgumentInt': [{'argInfo': {'index': {'doc': 'the index of the argument to the command ',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument as an int.',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the argument as an int',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'index': ['unsigned']},
                                                     'types': {'index': 'uint'}}],
                             'commandArgumentMAngle': [{'argInfo': {'index': {'doc': 'the index of the argument to the command ',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGets the value of the requested command argument as a  MAngle .',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the argument as a MAngle',
                                                                       'qualifiers': [],
                                                                       'type': 'MAngle'},
                                                        'returnType': 'MAngle',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'index': ['unsigned']},
                                                        'types': {'index': 'uint'}}],
                             'commandArgumentMDistance': [{'argInfo': {'index': {'doc': 'the index of the argument to the command ',
                                                                                 'type': 'uint'}},
                                                           'args': [('index',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nGets the value of the requested command argument as a  MDistance .',
                                                           'inArgs': ['index'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The value of the argument as a MDistance',
                                                                          'qualifiers': [],
                                                                          'type': 'MDistance'},
                                                           'returnType': 'MDistance',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'index': ['unsigned']},
                                                           'types': {'index': 'uint'}}],
                             'commandArgumentMTime': [{'argInfo': {'index': {'doc': 'the index of the argument to the command ',
                                                                             'type': 'uint'}},
                                                       'args': [('index',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGets the value of the requested command argument as a  MTime .',
                                                       'inArgs': ['index'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The value of the argument as a MTime',
                                                                      'qualifiers': [],
                                                                      'type': 'MTime'},
                                                       'returnType': 'MTime',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'index': ['unsigned']},
                                                       'types': {'index': 'uint'}}],
                             'commandArgumentString': [{'argInfo': {'index': {'doc': 'the index of the argument to the command ',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGets the value of the requested command argument as a string.',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the argument as a string',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'index': ['unsigned']},
                                                        'types': {'index': 'uint'}}],
                             'flagArgumentBool': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                        'type': 'char'},
                                                               'index': {'doc': 'index of the parameter to retrieve ',
                                                                         'type': 'uint'}},
                                                   'args': [('flag',
                                                             'char',
                                                             'in'),
                                                            ('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\r\nGets the value of the 'index'th parameter of the given flag as a boolean.",
                                                   'inArgs': ['flag',
                                                              'index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The value of the parameter as a boolean',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'flag': ['const',
                                                                               '*'],
                                                                      'index': ['unsigned']},
                                                   'types': {'flag': 'char',
                                                             'index': 'uint'}}],
                             'flagArgumentDouble': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                          'type': 'char'},
                                                                 'index': {'doc': 'index of the parameter to retrieve ',
                                                                           'type': 'uint'}},
                                                     'args': [('flag',
                                                               'char',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nGets the value of the 'index'th parameter of the given flag as a double.",
                                                     'inArgs': ['flag',
                                                                'index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the parameter as a double',
                                                                    'qualifiers': [],
                                                                    'type': 'double'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'flag': ['const',
                                                                                 '*'],
                                                                        'index': ['unsigned']},
                                                     'types': {'flag': 'char',
                                                               'index': 'uint'}}],
                             'flagArgumentInt': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an int.",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the parameter as an int',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint'}}],
                             'flagArgumentMAngle': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                          'type': 'char'},
                                                                 'index': {'doc': 'index of the parameter to retrieve ',
                                                                           'type': 'uint'}},
                                                     'args': [('flag',
                                                               'char',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MAngle .",
                                                     'inArgs': ['flag',
                                                                'index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the parameter as an MAngle',
                                                                    'qualifiers': [],
                                                                    'type': 'MAngle'},
                                                     'returnType': 'MAngle',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'flag': ['const',
                                                                                 '*'],
                                                                        'index': ['unsigned']},
                                                     'types': {'flag': 'char',
                                                               'index': 'uint'}}],
                             'flagArgumentMDistance': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                             'type': 'char'},
                                                                    'index': {'doc': 'index of the parameter to retrieve ',
                                                                              'type': 'uint'}},
                                                        'args': [('flag',
                                                                  'char',
                                                                  'in'),
                                                                 ('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MDistance .",
                                                        'inArgs': ['flag',
                                                                   'index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the parameter as an MDistance',
                                                                       'qualifiers': [],
                                                                       'type': 'MDistance'},
                                                        'returnType': 'MDistance',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'flag': ['const',
                                                                                    '*'],
                                                                           'index': ['unsigned']},
                                                        'types': {'flag': 'char',
                                                                  'index': 'uint'}}],
                             'flagArgumentMTime': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                         'type': 'char'},
                                                                'index': {'doc': 'index of the parameter to retrieve ',
                                                                          'type': 'uint'}},
                                                    'args': [('flag',
                                                              'char',
                                                              'in'),
                                                             ('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MTime .",
                                                    'inArgs': ['flag',
                                                               'index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the parameter as an MTime',
                                                                   'qualifiers': [],
                                                                   'type': 'MTime'},
                                                    'returnType': 'MTime',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'flag': ['const',
                                                                                '*'],
                                                                       'index': ['unsigned']},
                                                    'types': {'flag': 'char',
                                                              'index': 'uint'}}],
                             'flagArgumentString': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                          'type': 'char'},
                                                                 'index': {'doc': 'index of the parameter to retrieve ',
                                                                           'type': 'uint'}},
                                                     'args': [('flag',
                                                               'char',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MString .",
                                                     'inArgs': ['flag',
                                                                'index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the parameter as a string',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'flag': ['const',
                                                                                 '*'],
                                                                        'index': ['unsigned']},
                                                     'types': {'flag': 'char',
                                                               'index': 'uint'}}],
                             'getCommandArgument': [{'argInfo': {'index': {'doc': 'the index of the argument of the command ',
                                                                           'type': 'uint'},
                                                                 'result': {'doc': 'the value of the argument as a boolean',
                                                                            'type': 'bool'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('result',
                                                               'bool',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument to the command as a boolean.',
                                                     'inArgs': ['index'],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'result': ['&']},
                                                     'types': {'index': 'uint',
                                                               'result': 'bool'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the argument of the command ',
                                                                           'type': 'uint'},
                                                                 'result': {'doc': 'the value of the argument as a int',
                                                                            'type': 'int'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('result',
                                                               'int',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument to the command as an int.',
                                                     'inArgs': ['index'],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'result': ['&']},
                                                     'types': {'index': 'uint',
                                                               'result': 'int'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the argument of the command ',
                                                                           'type': 'uint'},
                                                                 'result': {'doc': 'the value of the argument as a double',
                                                                            'type': 'double'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('result',
                                                               'double',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument to the command as a double.',
                                                     'inArgs': ['index'],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'result': ['&']},
                                                     'types': {'index': 'uint',
                                                               'result': 'double'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the argument of the command ',
                                                                           'type': 'uint'},
                                                                 'result': {'doc': 'the value of the argument as an MString',
                                                                            'type': 'MString'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('result',
                                                               'MString',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument to the command as an  MString .',
                                                     'inArgs': ['index'],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'result': ['&']},
                                                     'types': {'index': 'uint',
                                                               'result': 'MString'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the argument of the command ',
                                                                           'type': 'uint'},
                                                                 'result': {'doc': 'the value of the argument as an MDistance',
                                                                            'type': 'MDistance'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('result',
                                                               'MDistance',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument to the command as an  MDistance .',
                                                     'inArgs': ['index'],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'result': ['&']},
                                                     'types': {'index': 'uint',
                                                               'result': 'MDistance'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the argument of the command ',
                                                                           'type': 'uint'},
                                                                 'result': {'doc': 'the value of the argument as an MAngle',
                                                                            'type': 'MAngle'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('result',
                                                               'MAngle',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument to the command as an  MAngle .',
                                                     'inArgs': ['index'],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'result': ['&']},
                                                     'types': {'index': 'uint',
                                                               'result': 'MAngle'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the argument of the command ',
                                                                           'type': 'uint'},
                                                                 'result': {'doc': 'the value of the argument as an MTime',
                                                                            'type': 'MTime'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('result',
                                                               'MTime',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the value of the requested command argument to the command as an  MTime .',
                                                     'inArgs': ['index'],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'result': ['&']},
                                                     'types': {'index': 'uint',
                                                               'result': 'MTime'}}],
                             'getFlagArgument': [{'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as a boolean',
                                                                         'type': 'bool'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'bool',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as a boolean.",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'bool'}},
                                                 {'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as an int',
                                                                         'type': 'int'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'int',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an int.",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'int'}},
                                                 {'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as a double',
                                                                         'type': 'double'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as a double.",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'double'}},
                                                 {'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as an MString',
                                                                         'type': 'MString'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'MString',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MString .",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'MString'}},
                                                 {'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as an unsigned int',
                                                                         'type': 'uint'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'uint',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an unsigned int.",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['unsigned',
                                                                                '&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'uint'}},
                                                 {'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as an MDistance',
                                                                         'type': 'MDistance'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'MDistance',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MDistance .",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'MDistance'}},
                                                 {'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as an MAngle',
                                                                         'type': 'MAngle'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'MAngle',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MAngle .",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'MAngle'}},
                                                 {'argInfo': {'flag': {'doc': 'flag whose parameter is being requested ',
                                                                       'type': 'char'},
                                                              'index': {'doc': 'index of the parameter to retrieve ',
                                                                        'type': 'uint'},
                                                              'result': {'doc': 'value of the parameter as an MTime',
                                                                         'type': 'MTime'}},
                                                  'args': [('flag',
                                                            'char',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('result',
                                                            'MTime',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets the value of the 'index'th parameter of the given flag as an  MTime .",
                                                  'inArgs': ['flag',
                                                             'index'],
                                                  'outArgs': ['result'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'flag': ['const',
                                                                              '*'],
                                                                     'index': ['unsigned'],
                                                                     'result': ['&']},
                                                  'types': {'flag': 'char',
                                                            'index': 'uint',
                                                            'result': 'MTime'}}],
                             'getFlagArgumentList': [{'argInfo': {'args': {'doc': "the parameters to the i'th usage of the specified flag",
                                                                           'type': 'MArgList'},
                                                                  'flag': {'doc': 'the flag whose parameters are being requested ',
                                                                           'type': 'char'},
                                                                  'i': {'doc': 'the desired instance of the flag on the command line ',
                                                                        'type': 'uint'}},
                                                      'args': [('flag',
                                                                'char',
                                                                'in'),
                                                               ('i',
                                                                'uint',
                                                                'in'),
                                                               ('args',
                                                                'MArgList',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nReturns an  MArgList  containing the parameters to the i'th usage of the specified flag. This call is only valid if the flag has been marked as available for multi-usage with  MSyntax::makeFlagMultiUse",
                                                      'inArgs': ['flag',
                                                                 'i'],
                                                      'outArgs': ['args'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'args': ['&'],
                                                                         'flag': ['const',
                                                                                  '*'],
                                                                         'i': ['unsigned']},
                                                      'types': {'args': 'MArgList',
                                                                'flag': 'char',
                                                                'i': 'uint'}}],
                             'getFlagArgumentPosition': [{'argInfo': {'flag': {'doc': 'flag whose position is being requested ',
                                                                               'type': 'char'},
                                                                      'i': {'doc': 'desired instance of the flag on the command line ',
                                                                            'type': 'uint'},
                                                                      'position': {'doc': "position in the command line of the i'th usage of the specified flag",
                                                                                   'type': 'uint'}},
                                                          'args': [('flag',
                                                                    'char',
                                                                    'in'),
                                                                   ('i',
                                                                    'uint',
                                                                    'in'),
                                                                   ('position',
                                                                    'uint',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\r\nReturns the position in the command line of the i'th usage of the specified flag. This call is only valid if the flag has been marked as available for multi-usage with  MSyntax::makeFlagMultiUse",
                                                          'inArgs': ['flag',
                                                                     'i'],
                                                          'outArgs': ['position'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'flag': ['const',
                                                                                      '*'],
                                                                             'i': ['unsigned'],
                                                                             'position': ['unsigned',
                                                                                          '&']},
                                                          'types': {'flag': 'char',
                                                                    'i': 'uint',
                                                                    'position': 'uint'}}],
                             'getObjects': [{'argInfo': {'result': {'doc': 'the list of objects passed to the command as an MStringArray',
                                                                    'type': 'MStringArray'}},
                                             'args': [('result',
                                                       'MStringArray',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGets the list of objects passed to the command as an array of strings.',
                                             'inArgs': [],
                                             'outArgs': ['result'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'result': ['&']},
                                             'types': {'result': 'MStringArray'}}],
                             'isEdit': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nDetermines if the edit flag was one of the arguments to the command. The edit flag in its short form is "-e", and in its int form is "-edit".',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': ' true if edit flag is set  false if edit flag is not set  ',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                             'isFlagSet': [{'argInfo': {'flag': {'doc': 'the flag whose state is to be queried ',
                                                                 'type': 'char'}},
                                            'args': [('flag',
                                                      'char',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nQueries the arguments to the command to determine if the given flag is set.',
                                            'inArgs': ['flag'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true if given flag is set  false if given flag is not set  ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'flag': ['const',
                                                                        '*']},
                                            'types': {'flag': 'char'}}],
                             'isQuery': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermines if the query flag was one of the arguments to the command. The query flag in its short form is "-q", and in its int form is "-query".',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true if query flag is set  false if query flag is not set  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                             'numberOfFlagUses': [{'argInfo': {'flag': {'doc': 'the flag whose argument is being requested',
                                                                        'type': 'char'}},
                                                   'args': [('flag',
                                                             'char',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the number of times the given flag was used on the command line.',
                                                   'inArgs': ['flag'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Number of times the given flag was used on the command line ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'flag': ['const',
                                                                               '*']},
                                                   'types': {'flag': 'char'}}],
                             'numberOfFlagsUsed': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the number of flags given on the command line.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                 'pymelEnums': {}},
  'MArrayDataBuilder': {'enums': {},
                        'methods': {'addElement': [{'argInfo': {'index': {'doc': 'the index at which we wish to add the new element ',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nAdds a new element to the array at the given index.',
                                                    'inArgs': ['index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The handle for the new element',
                                                                   'qualifiers': [],
                                                                   'type': 'MDataHandle'},
                                                    'returnType': 'MDataHandle',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'index': ['unsigned']},
                                                    'types': {'index': 'uint'}}],
                                    'addElementArray': [{'argInfo': {'index': {'doc': 'the index at which we wish to add the new element ',
                                                                               'type': 'uint'}},
                                                         'args': [('index',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nAdds a new element to the array at the given index. The added element is also an array.',
                                                         'inArgs': ['index'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The handle for the new array element',
                                                                        'qualifiers': [],
                                                                        'type': 'MArrayDataHandle'},
                                                         'returnType': 'MArrayDataHandle',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'index': ['unsigned']},
                                                         'types': {'index': 'uint'}}],
                                    'addLast': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdds a new element to the end of the array. The index of the element will be the current highest index + 1.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The handle for the new element',
                                                                'qualifiers': [],
                                                                'type': 'MDataHandle'},
                                                 'returnType': 'MDataHandle',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                    'addLastArray': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdds a new element to the end of the array. The added element is also an array. The index of the element will the current highest index + 1.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The handle for the new array element',
                                                                     'qualifiers': [],
                                                                     'type': 'MArrayDataHandle'},
                                                      'returnType': 'MArrayDataHandle',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'elementCount': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the number of elements in the array',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The number of elements',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                    'growArray': [{'argInfo': {'amount': {'doc': 'the amount to grow the array by',
                                                                          'type': 'uint'}},
                                                   'args': [('amount',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGrows the array storage by the given amount.',
                                                   'inArgs': ['amount'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'amount': ['unsigned']},
                                                   'types': {'amount': 'uint'}}],
                                    'removeElement': [{'argInfo': {'index': {'doc': 'the element of the array to remove',
                                                                             'type': 'uint'}},
                                                       'args': [('index',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nRemoves the specified element from the array',
                                                       'inArgs': ['index'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'index': ['unsigned']},
                                                       'types': {'index': 'uint'}}],
                                    'setGrowSize': [{'argInfo': {'size': {'doc': 'the number of elements to allocate when growing the array',
                                                                          'type': 'uint'}},
                                                     'args': [('size',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the grow size of the array. As elements are added to the array, the builder will allocate memory in chunks. This method tells the builder how many elements to allocate each time it grows the array.',
                                                     'inArgs': ['size'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'size': ['unsigned']},
                                                     'types': {'size': 'uint'}}]},
                        'pymelEnums': {}},
  'MArrayDataHandle': {'enums': {},
                       'methods': {'builder': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nReturns a builder for this handle's array so that it can be expanded.",
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The builder object',
                                                               'qualifiers': [],
                                                               'type': 'MArrayDataBuilder'},
                                                'returnType': 'MArrayDataBuilder',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                   'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'elementCount': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the number of elements in the array.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The number of elements',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'elementIndex': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the index that we are currently at in the array. It is possible for the index to be invalid, in which case the return status will report an error. These may be sparse arrays so the element index returned will be a logical index.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': "The current element's logical index",
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'inputArrayValue': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGets a handle into this data block for the current array element. This method should be used when the array elements are also arrays. The data represented by the handle will be valid. If the data is from an dirty connection, then the connection will be evailuated.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': "Data handle for the current element's data",
                                                                       'qualifiers': [],
                                                                       'type': 'MArrayDataHandle'},
                                                        'returnType': 'MArrayDataHandle',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                   'inputValue': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGets a handle into this data block for the current array element. The data represented by the handle will be valid. If the data is from an dirty connection, then the connection will be evaluated.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': "Data handle for the current element's data",
                                                                  'qualifiers': [],
                                                                  'type': 'MDataHandle'},
                                                   'returnType': 'MDataHandle',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                   'jumpToArrayElement': [{'argInfo': {'position': {'doc': 'the array position to jump to',
                                                                                    'type': 'uint'}},
                                                           'args': [('position',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nJump to a specific array element in the array. This method can be used to iterate over the entire array.',
                                                           'inArgs': ['position'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'position': ['unsigned']},
                                                           'types': {'position': 'uint'}}],
                                   'jumpToElement': [{'argInfo': {'index': {'doc': 'the logical index to jump to',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nJump to a specific element in the array. The array is sparse, so the indices may not be consecutive.',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                                   'next': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nAdvance to the next element in the array. These may be sparse arrays so the next consecutive element may not necessarily have a consecutive index.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                   'outputArrayValue': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGets a handle into this data block for the current array element. This method should be used when the array elements are also arrays. The data is not guaranteed to be valid. Therefore, this handle should only be used for writing over the data.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': "Data handle for the current element's data",
                                                                        'qualifiers': [],
                                                                        'type': 'MArrayDataHandle'},
                                                         'returnType': 'MArrayDataHandle',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                   'outputValue': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGets a handle into this data block for the current array element. The data is not guaranteed to be valid. Therefore, this handle should only be used for writing over the data.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': "Data handle for the current element's data",
                                                                   'qualifiers': [],
                                                                   'type': 'MDataHandle'},
                                                    'returnType': 'MDataHandle',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                   'set': [{'argInfo': {'builder': {'doc': 'the builder object',
                                                                    'type': 'MArrayDataBuilder'}},
                                            'args': [('builder',
                                                      'MArrayDataBuilder',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets the data for this array from the data in the builder object',
                                            'inArgs': ['builder'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'builder': ['&']},
                                            'types': {'builder': 'MArrayDataBuilder'}}],
                                   'setAllClean': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nMarks every element of the array attribute represented by the handle as clean. This method should be used if a compute function is asked to compute a single element of a multi, but instead calculates all the elements. Calling  setAllClean  in this situation will prevent further calls to the node's compute method for the other elements of the multi.",
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                   'setClean': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nMarks the data that is represented by this handle as being clean. This should be done after recalculating the data from the inputs.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                       'pymelEnums': {}},
  'MAttributeIndex': {'enums': {'MIndexType': {'valueDocs': {'float': 'Floating-poing index (e.g. curve.u[1.3]).',
                                                             'integer': 'Integer index (e.g. mesh.cp[5]).',
                                                             'kFloat': 'Floating-poing index (e.g. curve.u[1.3]).',
                                                             'kInteger': 'Integer index (e.g. mesh.cp[5]).'},
                                               'values': "Enum('MIndexType', {'kInteger': 0, 'kFloat': 1})"}},
                      'invertibles': [('setValue', 'getValue'),
                                      ('setUpper', 'getUpper'),
                                      ('setLower', 'getLower'),
                                      ('setType', 'type')],
                      'methods': {'__eq__': [{'argInfo': {'other': {'doc': 'object to compare with.',
                                                                    'type': 'MAttributeIndex'}},
                                              'args': [('other',
                                                        'MAttributeIndex',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nEquality operator.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean indicating whether the objects are same. ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&']},
                                              'types': {'other': 'MAttributeIndex'}}],
                                  '__ne__': [{'argInfo': {'other': {'doc': 'object to compare with.',
                                                                    'type': 'MAttributeIndex'}},
                                              'args': [('other',
                                                        'MAttributeIndex',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nInequality operator.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean indicating whether the objects are same. ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&']},
                                              'types': {'other': 'MAttributeIndex'}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'getLower': [{'argInfo': {'value': {'doc': 'lower bound value is returned through this parameter.',
                                                                      'type': 'int'}},
                                                'args': [('value',
                                                          'int',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the lower bound for this object or false if 1) the type does not match the argument type or 2) there is no lower bound. (both of which can be tested for using other methods on this class).',
                                                'inArgs': [],
                                                'inverse': ('setLower',
                                                            False),
                                                'outArgs': ['value'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': ['&']},
                                                'types': {'value': 'int'}},
                                               {'argInfo': {'value': {'doc': 'lower bound value is returned through this parameter.',
                                                                      'type': 'double'}},
                                                'args': [('value',
                                                          'double',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the lower bound for this object or false if 1) the type does not match the argument type or 2) there is no lower bound. (both of which can be tested for using other methods on this class).',
                                                'inArgs': [],
                                                'inverse': ('setLower',
                                                            False),
                                                'outArgs': ['value'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': ['&']},
                                                'types': {'value': 'double'}}],
                                  'getUpper': [{'argInfo': {'value': {'doc': 'upper bound value is returned through this parameter.',
                                                                      'type': 'int'}},
                                                'args': [('value',
                                                          'int',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the upper bound for this object or false if 1) the type does not match the argument type or 2) there is no upper bound. (both of which can be tested for using other methods on this class).',
                                                'inArgs': [],
                                                'inverse': ('setUpper',
                                                            False),
                                                'outArgs': ['value'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': ['&']},
                                                'types': {'value': 'int'}},
                                               {'argInfo': {'value': {'doc': 'upper bound value is returned through this parameter.',
                                                                      'type': 'double'}},
                                                'args': [('value',
                                                          'double',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the upper bound for this object or false if 1) the type does not match the argument type or 2) there is no upper bound. (both of which can be tested for using other methods on this class).',
                                                'inArgs': [],
                                                'inverse': ('setUpper',
                                                            False),
                                                'outArgs': ['value'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': ['&']},
                                                'types': {'value': 'double'}}],
                                  'getValue': [{'argInfo': {'value': {'doc': 'value of the index is returned through this parameter.',
                                                                      'type': 'int'}},
                                                'args': [('value',
                                                          'int',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the current value of the index or false if 1) the type does not match the argument type or 2) the index is a range or 3) the index is unbounded.',
                                                'inArgs': [],
                                                'inverse': ('setValue',
                                                            False),
                                                'outArgs': ['value'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': ['&']},
                                                'types': {'value': 'int'}},
                                               {'argInfo': {'value': {'doc': 'value of the index is returned through this parameter.',
                                                                      'type': 'double'}},
                                                'args': [('value',
                                                          'double',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the current value of the index or false if 1) the type does not match the argument type or 2) the index is a range or 3) the index is unbounded.',
                                                'inArgs': [],
                                                'inverse': ('setValue',
                                                            False),
                                                'outArgs': ['value'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': ['&']},
                                                'types': {'value': 'double'}}],
                                  'hasLowerBound': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn true if if there is a lower bound specified.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Boolean to indicate if there is a lower bound. ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                  'hasRange': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn true if a range was specified.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                  'hasUpperBound': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn true if if there is an upper bound specified.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Boolean to indicate if there is an upper bound. ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                  'hasValidRange': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn true if upper value is greater than lower value.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                  'isBounded': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if this object is bounded.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'setLower': [{'argInfo': {'value': {'doc': 'the value to set',
                                                                      'type': 'int'}},
                                                'args': [('value',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the lower bounds of this object.',
                                                'inArgs': ['value'],
                                                'inverse': ('getLower',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': 'int'}},
                                               {'argInfo': {'value': {'doc': 'the value to set',
                                                                      'type': 'double'}},
                                                'args': [('value',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the lower bounds of this object.',
                                                'inArgs': ['value'],
                                                'inverse': ('getLower',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': 'double'}}],
                                  'setType': [{'argInfo': {'type': {'doc': 'the index type to set',
                                                                    'type': ('MAttributeIndex',
                                                                             'MIndexType')}},
                                               'args': [('type',
                                                         ('MAttributeIndex',
                                                          'MIndexType'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets the type of attribute index.',
                                               'inArgs': ['type'],
                                               'inverse': ('type', True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'type': []},
                                               'types': {'type': ('MAttributeIndex',
                                                                  'MIndexType')}}],
                                  'setUpper': [{'argInfo': {'value': {'doc': 'the value to set',
                                                                      'type': 'int'}},
                                                'args': [('value',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the upper bounds of this object.',
                                                'inArgs': ['value'],
                                                'inverse': ('getUpper',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': 'int'}},
                                               {'argInfo': {'value': {'doc': 'the value to set',
                                                                      'type': 'double'}},
                                                'args': [('value',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the upper bounds of this object.',
                                                'inArgs': ['value'],
                                                'inverse': ('getUpper',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': 'double'}}],
                                  'setValue': [{'argInfo': {'value': {'doc': 'the value to set',
                                                                      'type': 'int'}},
                                                'args': [('value',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the index value of this object.',
                                                'inArgs': ['value'],
                                                'inverse': ('getValue',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': 'int'}},
                                               {'argInfo': {'value': {'doc': 'the value to set',
                                                                      'type': 'double'}},
                                                'args': [('value',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the index value of this object.',
                                                'inArgs': ['value'],
                                                'inverse': ('getValue',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': 'double'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the type of attribute index.',
                                            'inArgs': [],
                                            'inverse': ('setType', False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MAttributeIndex',
                                                                    'MIndexType')},
                                            'returnType': ('MAttributeIndex',
                                                           'MIndexType'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {'MIndexType': "Enum('MIndexType', [('integer', 0), ('kInteger', 0), ('float', 1), ('kFloat', 1)], multiKeys=True)"},
                      'pymelMethods': {'type': 'getType'}},
  'MAttributePattern': {'enums': {},
                        'methods': {'__eq__': [{'argInfo': {'rhs': {'doc': 'Pattern to be compared ',
                                                                    'type': 'MAttributePattern'}},
                                                'args': [('rhs',
                                                          'MAttributePattern',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nDetermine equality between two attribute patterns.',
                                                'inArgs': ['rhs'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true if they both point to the same underlying Maya pattern ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'rhs': ['const',
                                                                           '&']},
                                                'types': {'rhs': 'MAttributePattern'}}],
                                    'addRootAttr': [{'argInfo': {'attr': {'doc': 'Attribute to be added to this pattern.',
                                                                          'type': 'MObject'}},
                                                     'args': [('attr',
                                                               'MObject',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nAdd a new root attribute to the pattern.',
                                                     'inArgs': ['attr'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'attr': ['const',
                                                                                 '&']},
                                                     'types': {'attr': 'MObject'}}],
                                    'attrPattern': [{'argInfo': {'n': {'doc': 'The index in the global list of the pattern to be found',
                                                                       'type': 'uint'}},
                                                     'args': [('n',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nLook up an existing pattern by index value',
                                                     'inArgs': ['n'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Pattern with the given index, NULL if out of range ',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'MAttributePattern'},
                                                     'returnType': 'MAttributePattern',
                                                     'static': True,
                                                     'typeQualifiers': {'n': ['unsigned']},
                                                     'types': {'n': 'uint'}}],
                                    'attrPatternCount': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nGet the number of patterns currently known.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': True,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'findPattern': [{'argInfo': {'name': {'doc': 'The name of the pattern to be found',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nLook up an existing pattern by name',
                                                     'inArgs': ['name'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Pattern with the given name, NULL if not found ',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'MAttributePattern'},
                                                     'returnType': 'MAttributePattern',
                                                     'static': True,
                                                     'typeQualifiers': {'name': ['const',
                                                                                 '&']},
                                                     'types': {'name': 'MString'}}],
                                    'name': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nGet the name of this pattern',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this pattern.',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                    'removeRootAttr': [{'argInfo': {'idx': {'doc': 'Index of the root attribute to be removed',
                                                                            'type': 'uint'}},
                                                        'args': [('idx',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRemove a single root attribute and its children from the pattern by index.',
                                                        'inArgs': ['idx'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'idx': ['unsigned']},
                                                        'types': {'idx': 'uint'}},
                                                       {'argInfo': {'attr': {'doc': 'The attribute to be removed',
                                                                             'type': 'MObject'}},
                                                        'args': [('attr',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRemove a single root attribute and its children from the pattern by attribute.',
                                                        'inArgs': ['attr'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'attr': ['const',
                                                                                    '&']},
                                                        'types': {'attr': 'MObject'}}],
                                    'rootAttr': [{'argInfo': {'idx': {'doc': "Index of the root-level attribute in the pattern's list. ",
                                                                      'type': 'uint'}},
                                                  'args': [('idx',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nGet a single root-level attribute from this pattern.',
                                                  'inArgs': ['idx'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': "The idx'th root attribute present in the pattern.",
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'idx': ['unsigned']},
                                                  'types': {'idx': 'uint'}}],
                                    'rootAttrCount': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nGet the number of top level attributes present in this pattern.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Number of root attributes present in this pattern',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}]},
                        'pymelEnums': {}},
  'MAttributePatternArray': {'enums': {},
                             'invertibles': [('setSizeIncrement',
                                              'sizeIncrement'),
                                             ('setLength', 'length')],
                             'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'Zero-based index to the array',
                                                                                'type': 'uint'}},
                                                          'args': [('index',
                                                                    'uint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nRetrieves the read-only attribute pattern which is at the specified index in the array.',
                                                          'inArgs': ['index'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Attribute pattern at the specified index ',
                                                                         'qualifiers': ['&'],
                                                                         'type': 'MAttributePattern'},
                                                          'returnType': 'MAttributePattern',
                                                          'static': False,
                                                          'typeQualifiers': {'index': ['unsigned']},
                                                          'types': {'index': 'uint'}},
                                                         {'argInfo': {'index': {'doc': 'Zero-based index to the array',
                                                                                'type': 'uint'}},
                                                          'args': [('index',
                                                                    'uint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nRetrieves the attribute pattern which is at the specified index in the array.',
                                                          'inArgs': ['index'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Attribute pattern at the specified index ',
                                                                         'qualifiers': ['&'],
                                                                         'type': 'MAttributePattern'},
                                                          'returnType': 'MAttributePattern',
                                                          'static': False,
                                                          'typeQualifiers': {'index': ['unsigned']},
                                                          'types': {'index': 'uint'}}],
                                         'append': [{'argInfo': {'element': {'doc': 'attribute pattern to be appended',
                                                                             'type': 'MAttributePattern'}},
                                                     'args': [('element',
                                                               'MAttributePattern',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nAppends the given attribute pattern to the end of the array.',
                                                     'inArgs': ['element'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'element': ['const',
                                                                                    '&']},
                                                     'types': {'element': 'MAttributePattern'}}],
                                         'className': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturns the name of this class.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'char'},
                                                        'returnType': 'char',
                                                        'static': True,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                         'clear': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nClears this array. Length of the array becomes zero.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                         'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                          'type': 'MAttributePatternArray'}},
                                                   'args': [('source',
                                                             'MAttributePatternArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nCopy the contents of the source array to this array.',
                                                   'inArgs': ['source'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'source': ['const',
                                                                                 '&']},
                                                   'types': {'source': 'MAttributePatternArray'}}],
                                         'insert': [{'argInfo': {'element': {'doc': 'attribute pattern to be inserted ',
                                                                             'type': 'MAttributePattern'},
                                                                 'index': {'doc': 'Zero-based index to the array',
                                                                           'type': 'uint'}},
                                                     'args': [('element',
                                                               'MAttributePattern',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nInserts the given attribute pattern at the specified index in the array.',
                                                     'inArgs': ['element',
                                                                'index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'element': ['const',
                                                                                    '&'],
                                                                        'index': ['unsigned']},
                                                     'types': {'element': 'MAttributePattern',
                                                               'index': 'uint'}}],
                                         'length': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nDetermines the number of elements in the array.',
                                                     'inArgs': [],
                                                     'inverse': ('setLength',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                         'remove': [{'argInfo': {'index': {'doc': 'Zero-based index to the array',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRemoves the attribute pattern which is at the specified index in the array.',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}}],
                                         'set': [{'argInfo': {'element': {'doc': 'New attribute pattern to be set on the indicated element ',
                                                                          'type': 'MAttributePattern'},
                                                              'index': {'doc': 'Zero-based index to the array',
                                                                        'type': 'uint'}},
                                                  'args': [('element',
                                                            'MAttributePattern',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nSets an element of the array to the given attribute pattern.',
                                                  'inArgs': ['element',
                                                             'index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'element': ['const',
                                                                                 '&'],
                                                                     'index': ['unsigned']},
                                                  'types': {'element': 'MAttributePattern',
                                                            'index': 'uint'}}],
                                         'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                               'type': 'uint'}},
                                                        'args': [('length',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                                        'inArgs': ['length'],
                                                        'inverse': ('length',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'length': ['unsigned']},
                                                        'types': {'length': 'uint'}}],
                                         'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                            'type': 'uint'}},
                                                               'args': [('newIncrement',
                                                                         'uint',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                               'inArgs': ['newIncrement'],
                                                               'inverse': ('sizeIncrement',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'newIncrement': ['unsigned']},
                                                               'types': {'newIncrement': 'uint'}}],
                                         'sizeIncrement': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                            'inArgs': [],
                                                            'inverse': ('setSizeIncrement',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'int'},
                                                            'returnType': 'int',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}]},
                             'pymelEnums': {},
                             'pymelMethods': {'length': 'getLength',
                                              'sizeIncrement': 'getSizeIncrement'}},
  'MAttributeSpec': {'enums': {},
                     'invertibles': [('setDimensions', 'dimensions'),
                                     ('setName', 'name')],
                     'methods': {'__eq__': [{'argInfo': {'other': {'doc': 'attribute specifier to be compared',
                                                                   'type': 'MAttributeSpec'}},
                                             'args': [('other',
                                                       'MAttributeSpec',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nComparison operator.',
                                             'inArgs': ['other'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The boolean indicating whether the object are same or not. ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'other': ['const',
                                                                          '&']},
                                             'types': {'other': 'MAttributeSpec'}}],
                                 '__getitem__': [{'argInfo': {'index': {'doc': 'attribute index to return',
                                                                        'type': 'int'}},
                                                  'args': [('index',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns an attribute index object for the specified element.',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The MAttributeIndex associated with the given index. ',
                                                                 'qualifiers': [],
                                                                 'type': 'MAttributeIndex'},
                                                  'returnType': 'MAttributeIndex',
                                                  'static': False,
                                                  'typeQualifiers': {'index': []},
                                                  'types': {'index': 'int'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'dimensions': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the dimension of the attribute specification. For array attributes the dimension is > 0.',
                                                 'inArgs': [],
                                                 'inverse': ('setDimensions',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The attributes dimension ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                 'name': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the attribute name part of the specification.',
                                           'inArgs': [],
                                           'inverse': ('setName', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The attribute name ',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                 'setDimensions': [{'argInfo': {'value': {'doc': 'the dimension value to be set ',
                                                                          'type': 'int'}},
                                                    'args': [('value',
                                                              'int',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the dimension of the attribute specification. Array attribute dimensions are > 0.',
                                                    'inArgs': ['value'],
                                                    'inverse': ('dimensions',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'value': []},
                                                    'types': {'value': 'int'}}],
                                 'setName': [{'argInfo': {'name': {'doc': 'the name to be set ',
                                                                   'type': 'MString'}},
                                              'args': [('name',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the attribute name part of the specification.',
                                              'inArgs': ['name'],
                                              'inverse': ('name', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'name': ['const',
                                                                          '&']},
                                              'types': {'name': 'MString'}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'dimensions': 'getDimensions',
                                      'name': 'getName'}},
  'MAttributeSpecArray': {'enums': {},
                          'invertibles': [('setSizeIncrement',
                                           'sizeIncrement'),
                                          ('setLength', 'length')],
                          'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element to return',
                                                                             'type': 'uint'}},
                                                       'args': [('index',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nIndex operator. Returns the value of the element at the given index. Valid indices are 0 to  length() -1.',
                                                       'inArgs': ['index'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A reference to the specified element ',
                                                                      'qualifiers': [],
                                                                      'type': 'MAttributeSpec'},
                                                       'returnType': 'MAttributeSpec',
                                                       'static': False,
                                                       'typeQualifiers': {'index': ['unsigned']},
                                                       'types': {'index': 'uint'}}],
                                      'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                          'type': 'MAttributeSpec'}},
                                                  'args': [('element',
                                                            'MAttributeSpec',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAdds a new element to the end of the array.',
                                                  'inArgs': ['element'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'element': ['const',
                                                                                 '&']},
                                                  'types': {'element': 'MAttributeSpec'}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'clear': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                      'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                       'type': 'MAttributeSpecArray'}},
                                                'args': [('source',
                                                          'MAttributeSpecArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCopy the contents of the source array to this array.',
                                                'inArgs': ['source'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'source': ['const',
                                                                              '&']},
                                                'types': {'source': 'MAttributeSpecArray'}}],
                                      'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                          'type': 'MAttributeSpec'},
                                                              'index': {'doc': 'the index of the element to set',
                                                                        'type': 'uint'}},
                                                  'args': [('element',
                                                            'MAttributeSpec',
                                                            'in'),
                                                           ('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last.',
                                                  'inArgs': ['element',
                                                             'index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'element': ['const',
                                                                                 '&'],
                                                                     'index': ['unsigned']},
                                                  'types': {'element': 'MAttributeSpec',
                                                            'index': 'uint'}}],
                                      'length': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the number of elements in the array.',
                                                  'inArgs': [],
                                                  'inverse': ('setLength',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The number of elements in the array ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                      'remove': [{'argInfo': {'index': {'doc': 'the index of the element to removed',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRemoves the element in the array at the given index.',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}],
                                      'set': [{'argInfo': {'element': {'doc': 'the new value for the specified element ',
                                                                       'type': 'MAttributeSpec'},
                                                           'index': {'doc': 'the index of the element to be set',
                                                                     'type': 'uint'}},
                                               'args': [('element',
                                                         'MAttributeSpec',
                                                         'in'),
                                                        ('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets the value of the specified element to the given attribute spec.',
                                               'inArgs': ['element',
                                                          'index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'element': ['const',
                                                                              '&'],
                                                                  'index': ['unsigned']},
                                               'types': {'element': 'MAttributeSpec',
                                                         'index': 'uint'}}],
                                      'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array',
                                                                            'type': 'uint'}},
                                                     'args': [('length',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                                     'inArgs': ['length'],
                                                     'inverse': ('length',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'length': ['unsigned']},
                                                     'types': {'length': 'uint'}}],
                                      'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                         'type': 'uint'}},
                                                            'args': [('newIncrement',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                            'inArgs': ['newIncrement'],
                                                            'inverse': ('sizeIncrement',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'newIncrement': ['unsigned']},
                                                            'types': {'newIncrement': 'uint'}}],
                                      'sizeIncrement': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                         'inArgs': [],
                                                         'inverse': ('setSizeIncrement',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'length': 'getLength',
                                           'sizeIncrement': 'getSizeIncrement'}},
  'MBoundingBox': {'enums': {},
                   'methods': {'center': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the center of the bounding box.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MPoint'},
                                           'returnType': 'MPoint',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nEmpties the current bounding box. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'contains': [{'argInfo': {'point': {'doc': 'point to check for inclusion in this bounding box',
                                                                   'type': 'MPoint'}},
                                             'args': [('point',
                                                       'MPoint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns true if the bounding box contains the given point.',
                                             'inArgs': ['point'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'true if the point is contained in this bounding box ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'point': ['const',
                                                                          '&']},
                                             'types': {'point': 'MPoint'}}],
                               'depth': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the depth of the bounding box.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The depth of the bounding box ',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'expand': [{'argInfo': {'point': {'doc': 'new point to include in the bounding box. ',
                                                                 'type': 'MPoint'}},
                                           'args': [('point',
                                                     'MPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nExpand the bounding box to include the given point.',
                                           'inArgs': ['point'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'point': ['const',
                                                                        '&']},
                                           'types': {'point': 'MPoint'}},
                                          {'argInfo': {'box': {'doc': 'bounding box to include in this bounding box. ',
                                                               'type': 'MBoundingBox'}},
                                           'args': [('box',
                                                     'MBoundingBox',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nExpand the bounding box to include a second bounding box.',
                                           'inArgs': ['box'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'box': ['const',
                                                                      '&']},
                                           'types': {'box': 'MBoundingBox'}}],
                               'height': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the height of the bounding box.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The height of the bounding box ',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'intersects': [{'argInfo': {'box': {'doc': 'bounding box to check for intersection ',
                                                                   'type': 'MBoundingBox'},
                                                           'tol': {'doc': 'tolerance of the intersection check',
                                                                   'type': 'double'}},
                                               'args': [('box',
                                                         'MBoundingBox',
                                                         'in'),
                                                        ('tol',
                                                         'double',
                                                         'in')],
                                               'defaults': {'tol': 0.0},
                                               'deprecated': False,
                                               'doc': '\r\nReturns true if the bounding box intersects another given bounding box',
                                               'inArgs': ['box', 'tol'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if the bounding boxes intersect ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'box': ['const',
                                                                          '&'],
                                                                  'tol': []},
                                               'types': {'box': 'MBoundingBox',
                                                         'tol': 'double'}}],
                               'max': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "\r\nReturns the maximum point for the bounding box. That is the point whose x, y, and z components represent the bounding box's maximum value in each dimension.",
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The maximum point of the bounding box ',
                                                       'qualifiers': [],
                                                       'type': 'MPoint'},
                                        'returnType': 'MPoint',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                               'min': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "\r\nReturns the minimum point for the bounding box. That is the point whose x, y, and z components represent the bounding box's minimum value in each dimension.",
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The minimum point of the bounding box ',
                                                       'qualifiers': [],
                                                       'type': 'MPoint'},
                                        'returnType': 'MPoint',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                               'transformUsing': [{'argInfo': {'matrix': {'doc': 'transformation matrix ',
                                                                          'type': 'MMatrix'}},
                                                   'args': [('matrix',
                                                             'MMatrix',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nApply the given transformation to this bounding box.',
                                                   'inArgs': ['matrix'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'matrix': ['const',
                                                                                 '&']},
                                                   'types': {'matrix': 'MMatrix'}}],
                               'width': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the width of the bounding box.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The width of the bounding box ',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                   'pymelEnums': {}},
  'MCacheFormatDescription': {'enums': {'CacheDataType': {'valueDocs': {'double': 'a single double value',
                                                                        'doubleArray': 'an array of double values',
                                                                        'doubleVectorArray': 'an array of double vector values',
                                                                        'floatArray': 'an array of float values',
                                                                        'floatVectorArray': 'an array of float vector values',
                                                                        'int32Array': 'an array of int32 values',
                                                                        'kDouble': 'a single double value',
                                                                        'kDoubleArray': 'an array of double values',
                                                                        'kDoubleVectorArray': 'an array of double vector values',
                                                                        'kFloatArray': 'an array of float values',
                                                                        'kFloatVectorArray': 'an array of float vector values',
                                                                        'kInt32Array': 'an array of int32 values',
                                                                        'kUnknownData': 'unknown data',
                                                                        'unknownData': 'unknown data'},
                                                          'values': "Enum('CacheDataType', {'kUnknownData': 0, 'kDouble': 1, 'kDoubleArray': 2, 'kDoubleVectorArray': 3, 'kInt32Array': 4, 'kFloatArray': 5, 'kFloatVectorArray': 6})"},
                                        'CacheFileDistribution': {'valueDocs': {'kNoFile': 'just memory cache',
                                                                                'kOneFile': 'one file for all frames',
                                                                                'kOneFilePerFrame': 'one file per frame',
                                                                                'noFile': 'just memory cache',
                                                                                'oneFile': 'one file for all frames',
                                                                                'oneFilePerFrame': 'one file per frame'},
                                                                  'values': "Enum('CacheFileDistribution', {'kNoFile': 0, 'kOneFile': 1, 'kOneFilePerFrame': 2})"},
                                        'CacheSamplingType': {'valueDocs': {'irregular': 'irregular sampling',
                                                                            'kIrregular': 'irregular sampling',
                                                                            'kRegular': 'regular sampling',
                                                                            'regular': 'regular sampling'},
                                                              'values': "Enum('CacheSamplingType', {'kRegular': 0, 'kIrregular': 1})"}},
                              'invertibles': [('setTimePerFrame',
                                               'getTimePerFrame'),
                                              ('setDistribution',
                                               'getDistribution')],
                              'methods': {'addChannel': [{'argInfo': {'channelName': {'doc': "the new channel's name ",
                                                                                      'type': 'MString'},
                                                                      'dataType': {'doc': "the new channel's data type ",
                                                                                   'type': ('MCacheFormatDescription',
                                                                                            'CacheDataType')},
                                                                      'endTime': {'doc': "the new channel's end time ",
                                                                                  'type': 'MTime'},
                                                                      'interpretation': {'doc': "the new channel's interpretation ",
                                                                                         'type': 'MString'},
                                                                      'samplingRate': {'doc': "the new channel's sampling rate ",
                                                                                       'type': 'MTime'},
                                                                      'samplingType': {'doc': "the new channel's sampling type ",
                                                                                       'type': ('MCacheFormatDescription',
                                                                                                'CacheSamplingType')},
                                                                      'startTime': {'doc': "the new channel's start time ",
                                                                                    'type': 'MTime'}},
                                                          'args': [('channelName',
                                                                    'MString',
                                                                    'in'),
                                                                   ('interpretation',
                                                                    'MString',
                                                                    'in'),
                                                                   ('dataType',
                                                                    ('MCacheFormatDescription',
                                                                     'CacheDataType'),
                                                                    'in'),
                                                                   ('samplingType',
                                                                    ('MCacheFormatDescription',
                                                                     'CacheSamplingType'),
                                                                    'in'),
                                                                   ('samplingRate',
                                                                    'MTime',
                                                                    'in'),
                                                                   ('startTime',
                                                                    'MTime',
                                                                    'in'),
                                                                   ('endTime',
                                                                    'MTime',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nAdd a channel.',
                                                          'inArgs': ['channelName',
                                                                     'interpretation',
                                                                     'dataType',
                                                                     'samplingType',
                                                                     'samplingRate',
                                                                     'startTime',
                                                                     'endTime'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The index of the added channel.',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'channelName': ['const',
                                                                                             '&'],
                                                                             'dataType': [],
                                                                             'endTime': ['const',
                                                                                         '&'],
                                                                             'interpretation': ['const',
                                                                                                '&'],
                                                                             'samplingRate': ['const',
                                                                                              '&'],
                                                                             'samplingType': [],
                                                                             'startTime': ['const',
                                                                                           '&'],
                                                                             'status': ['*']},
                                                          'types': {'channelName': 'MString',
                                                                    'dataType': ('MCacheFormatDescription',
                                                                                 'CacheDataType'),
                                                                    'endTime': 'MTime',
                                                                    'interpretation': 'MString',
                                                                    'samplingRate': 'MTime',
                                                                    'samplingType': ('MCacheFormatDescription',
                                                                                     'CacheSamplingType'),
                                                                    'startTime': 'MTime'}}],
                                          'addDescriptionInfo': [{'argInfo': {'info': {'doc': 'the string to add ',
                                                                                       'type': 'MString'}},
                                                                  'args': [('info',
                                                                            'MString',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nAdd a descriptive string.',
                                                                  'inArgs': ['info'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'info': ['const',
                                                                                              '&']},
                                                                  'types': {'info': 'MString'}}],
                                          'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the name of this class.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'getChannelDataType': [{'argInfo': {'channelIndex': {'doc': 'the index of the channel to be queried',
                                                                                               'type': 'uint'}},
                                                                  'args': [('channelIndex',
                                                                            'uint',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': "\nGet a channel's data type.",
                                                                  'inArgs': ['channelIndex'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': "the channel's data type ",
                                                                                 'qualifiers': [],
                                                                                 'type': ('MCacheFormatDescription',
                                                                                          'CacheDataType')},
                                                                  'returnType': ('MCacheFormatDescription',
                                                                                 'CacheDataType'),
                                                                  'static': False,
                                                                  'typeQualifiers': {'channelIndex': ['unsigned']},
                                                                  'types': {'channelIndex': 'uint'}}],
                                          'getChannelEndTime': [{'argInfo': {'channelIndex': {'doc': 'the index of the channel to be queried',
                                                                                              'type': 'uint'}},
                                                                 'args': [('channelIndex',
                                                                           'uint',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': "\nGet a channel's end time.",
                                                                 'inArgs': ['channelIndex'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': "the channel's end time ",
                                                                                'qualifiers': [],
                                                                                'type': 'MTime'},
                                                                 'returnType': 'MTime',
                                                                 'static': False,
                                                                 'typeQualifiers': {'channelIndex': ['unsigned']},
                                                                 'types': {'channelIndex': 'uint'}}],
                                          'getChannelInterpretation': [{'argInfo': {'channelIndex': {'doc': 'the index of the channel to be queried',
                                                                                                     'type': 'uint'}},
                                                                        'args': [('channelIndex',
                                                                                  'uint',
                                                                                  'in')],
                                                                        'defaults': {},
                                                                        'deprecated': False,
                                                                        'doc': "\nGet a channel's intepretation.",
                                                                        'inArgs': ['channelIndex'],
                                                                        'outArgs': [],
                                                                        'returnInfo': {'doc': "the channel's intepretation ",
                                                                                       'qualifiers': [],
                                                                                       'type': 'MString'},
                                                                        'returnType': 'MString',
                                                                        'static': False,
                                                                        'typeQualifiers': {'channelIndex': ['unsigned']},
                                                                        'types': {'channelIndex': 'uint'}}],
                                          'getChannelName': [{'argInfo': {'channelIndex': {'doc': 'the index of the channel to be queried',
                                                                                           'type': 'uint'}},
                                                              'args': [('channelIndex',
                                                                        'uint',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': "\nGet a channel's name.",
                                                              'inArgs': ['channelIndex'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': "the channel's name ",
                                                                             'qualifiers': [],
                                                                             'type': 'MString'},
                                                              'returnType': 'MString',
                                                              'static': False,
                                                              'typeQualifiers': {'channelIndex': ['unsigned']},
                                                              'types': {'channelIndex': 'uint'}}],
                                          'getChannelSamplingRate': [{'argInfo': {'channelIndex': {'doc': 'the index of the channel to be queried',
                                                                                                   'type': 'uint'}},
                                                                      'args': [('channelIndex',
                                                                                'uint',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': "\nGet a channel's sampling rate.",
                                                                      'inArgs': ['channelIndex'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': "the channel's sampling rate ",
                                                                                     'qualifiers': [],
                                                                                     'type': 'MTime'},
                                                                      'returnType': 'MTime',
                                                                      'static': False,
                                                                      'typeQualifiers': {'channelIndex': ['unsigned']},
                                                                      'types': {'channelIndex': 'uint'}}],
                                          'getChannelSamplingType': [{'argInfo': {'channelIndex': {'doc': 'the index of the channel to be queried',
                                                                                                   'type': 'uint'}},
                                                                      'args': [('channelIndex',
                                                                                'uint',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': "\nGet a channel's sampling type.",
                                                                      'inArgs': ['channelIndex'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': "the channel's sampling type ",
                                                                                     'qualifiers': [],
                                                                                     'type': ('MCacheFormatDescription',
                                                                                              'CacheSamplingType')},
                                                                      'returnType': ('MCacheFormatDescription',
                                                                                     'CacheSamplingType'),
                                                                      'static': False,
                                                                      'typeQualifiers': {'channelIndex': ['unsigned']},
                                                                      'types': {'channelIndex': 'uint'}}],
                                          'getChannelStartTime': [{'argInfo': {'channelIndex': {'doc': 'the index of the channel to be queried',
                                                                                                'type': 'uint'}},
                                                                   'args': [('channelIndex',
                                                                             'uint',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': "\nGet a channel's start time.",
                                                                   'inArgs': ['channelIndex'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': "the channel's start time ",
                                                                                  'qualifiers': [],
                                                                                  'type': 'MTime'},
                                                                   'returnType': 'MTime',
                                                                   'static': False,
                                                                   'typeQualifiers': {'channelIndex': ['unsigned']},
                                                                   'types': {'channelIndex': 'uint'}}],
                                          'getDescriptionInfo': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nGet the descriptive strings.',
                                                                  'inArgs': [],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': 'MStringArray'},
                                                                  'returnType': 'MStringArray',
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                                          'getDistribution': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nGet information about the format in order to write the description file. \n',
                                                               'inArgs': [],
                                                               'inverse': ('setDistribution',
                                                                           False),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': ('MCacheFormatDescription',
                                                                                       'CacheFileDistribution')},
                                                               'returnType': ('MCacheFormatDescription',
                                                                              'CacheFileDistribution'),
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               'types': {}}],
                                          'getNumChannels': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nGet the number of channels.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': 'int'},
                                                              'returnType': 'int',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                          'getStartAndEndTimes': [{'argInfo': {'endTime': {'doc': 'the end time ',
                                                                                           'type': 'MTime'},
                                                                               'startTime': {'doc': 'the start time ',
                                                                                             'type': 'MTime'}},
                                                                   'args': [('startTime',
                                                                             'MTime',
                                                                             'out'),
                                                                            ('endTime',
                                                                             'MTime',
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nGet the start and end times.',
                                                                   'inArgs': [],
                                                                   'outArgs': ['startTime',
                                                                               'endTime'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'endTime': ['&'],
                                                                                      'startTime': ['&']},
                                                                   'types': {'endTime': 'MTime',
                                                                             'startTime': 'MTime'}}],
                                          'getTimePerFrame': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nGet the time per frame.',
                                                               'inArgs': [],
                                                               'inverse': ('setTimePerFrame',
                                                                           False),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': 'MTime'},
                                                               'returnType': 'MTime',
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               'types': {}}],
                                          'setDistribution': [{'argInfo': {'distribution': {'doc': 'the distribution to set ',
                                                                                            'type': ('MCacheFormatDescription',
                                                                                                     'CacheFileDistribution')}},
                                                               'args': [('distribution',
                                                                         ('MCacheFormatDescription',
                                                                          'CacheFileDistribution'),
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nSet up the cache format when reading the description file. \n',
                                                               'inArgs': ['distribution'],
                                                               'inverse': ('getDistribution',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'distribution': []},
                                                               'types': {'distribution': ('MCacheFormatDescription',
                                                                                          'CacheFileDistribution')}}],
                                          'setTimePerFrame': [{'argInfo': {'timePerFrame': {'doc': 'the time per frame to set ',
                                                                                            'type': 'MTime'}},
                                                               'args': [('timePerFrame',
                                                                         'MTime',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nSet the time per frame.',
                                                               'inArgs': ['timePerFrame'],
                                                               'inverse': ('getTimePerFrame',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'timePerFrame': ['const',
                                                                                                   '&']},
                                                               'types': {'timePerFrame': 'MTime'}}]},
                              'pymelEnums': {'CacheDataType': "Enum('CacheDataType', [('unknownData', 0), ('kUnknownData', 0), ('double', 1), ('kDouble', 1), ('doubleArray', 2), ('kDoubleArray', 2), ('doubleVectorArray', 3), ('kDoubleVectorArray', 3), ('int32Array', 4), ('kInt32Array', 4), ('floatArray', 5), ('kFloatArray', 5), ('floatVectorArray', 6), ('kFloatVectorArray', 6)], multiKeys=True)",
                                             'CacheFileDistribution': "Enum('CacheFileDistribution', [('noFile', 0), ('kNoFile', 0), ('oneFile', 1), ('kOneFile', 1), ('oneFilePerFrame', 2), ('kOneFilePerFrame', 2)], multiKeys=True)",
                                             'CacheSamplingType': "Enum('CacheSamplingType', [('regular', 0), ('kRegular', 0), ('irregular', 1), ('kIrregular', 1)], multiKeys=True)"}},
  'MCallbackIdArray': {'enums': {},
                       'invertibles': [('setSizeIncrement',
                                        'sizeIncrement'),
                                       ('setLength', 'length')],
                       'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                    'inArgs': ['index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the indicated element. ',
                                                                   'qualifiers': [],
                                                                   'type': 'MCallbackId'},
                                                    'returnType': 'MCallbackId',
                                                    'static': False,
                                                    'typeQualifiers': {'index': ['unsigned']},
                                                    'types': {'index': 'uint'}},
                                                   {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                    'inArgs': ['index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A reference to the indicated element ',
                                                                   'qualifiers': ['&'],
                                                                   'type': 'MCallbackId'},
                                                    'returnType': 'MCallbackId',
                                                    'static': False,
                                                    'typeQualifiers': {'index': ['unsigned']},
                                                    'types': {'index': 'uint'}}],
                                   'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                       'type': 'MCallbackId'}},
                                               'args': [('element',
                                                         'MCallbackId',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                               'inArgs': ['element'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'element': []},
                                               'types': {'element': 'MCallbackId'}}],
                                   'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'clear': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                   'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                    'type': 'MCallbackIdArray'}},
                                             'args': [('source',
                                                       'MCallbackIdArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCopy the contents of the source array to this array.',
                                             'inArgs': ['source'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'source': ['const',
                                                                           '&']},
                                             'types': {'source': 'MCallbackIdArray'}}],
                                   'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                                  'type': 'MCallbackId__array'}},
                                            'args': [('array',
                                                      'MCallbackId__array',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': [],
                                            'outArgs': ['array'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'array': []},
                                            'types': {'array': 'MCallbackId__array'}}],
                                   'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                       'type': 'MCallbackId'},
                                                           'index': {'doc': 'the index of the element to set to the new value',
                                                                     'type': 'uint'}},
                                               'args': [('element',
                                                         'MCallbackId',
                                                         'in'),
                                                        ('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                               'inArgs': ['element',
                                                          'index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'element': [],
                                                                  'index': ['unsigned']},
                                               'types': {'element': 'MCallbackId',
                                                         'index': 'uint'}}],
                                   'length': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the number of elements in the instance.',
                                               'inArgs': [],
                                               'inverse': ('setLength',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The number of elements in the instance ',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                   'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                                   'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                    'type': 'MCallbackId'},
                                                        'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                  'type': 'uint'}},
                                            'args': [('element',
                                                      'MCallbackId',
                                                      'in'),
                                                     ('index',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets the value of the indicated element to the indicated value.',
                                            'inArgs': ['element',
                                                       'index'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'element': [],
                                                               'index': ['unsigned']},
                                            'types': {'element': 'MCallbackId',
                                                      'index': 'uint'}}],
                                   'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                         'type': 'uint'}},
                                                  'args': [('length',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                                  'inArgs': ['length'],
                                                  'inverse': ('length',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'length': ['unsigned']},
                                                  'types': {'length': 'uint'}}],
                                   'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                      'type': 'uint'}},
                                                         'args': [('newIncrement',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                         'inArgs': ['newIncrement'],
                                                         'inverse': ('sizeIncrement',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'newIncrement': ['unsigned']},
                                                         'types': {'newIncrement': 'uint'}}],
                                   'sizeIncrement': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                      'inArgs': [],
                                                      'inverse': ('setSizeIncrement',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                       'pymelEnums': {},
                       'pymelMethods': {'length': 'getLength',
                                        'sizeIncrement': 'getSizeIncrement'}},
  'MCameraSetMessage': {'enums': {},
                        'methods': {'addCameraChangedCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                             'type': 'void'},
                                                                              'func': {'doc': 'the callback function',
                                                                                       'type': ('MMessage',
                                                                                                'MCameraLayerCameraFunction')}},
                                                                  'args': [('func',
                                                                            ('MMessage',
                                                                             'MCameraLayerCameraFunction'),
                                                                            'in'),
                                                                           ('clientData',
                                                                            'void',
                                                                            'in')],
                                                                  'defaults': {'clientData': None},
                                                                  'deprecated': False,
                                                                  'doc': '\nRegisters callbacks for camera assignment changes to a camera layer.',
                                                                  'inArgs': ['func',
                                                                             'clientData'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'MCallbackId'},
                                                                  'returnType': 'MCallbackId',
                                                                  'static': True,
                                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                     'clientData': ['*'],
                                                                                     'func': []},
                                                                  'types': {'clientData': 'void',
                                                                            'func': ('MMessage',
                                                                                     'MCameraLayerCameraFunction')}}],
                                    'addCameraLayerCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                           'type': 'void'},
                                                                            'func': {'doc': 'the callback function',
                                                                                     'type': ('MMessage',
                                                                                              'MCameraLayerFunction')}},
                                                                'args': [('func',
                                                                          ('MMessage',
                                                                           'MCameraLayerFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': '\nRegisters callbacks for adding and removing camera layeres.',
                                                                'inArgs': ['func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'func': []},
                                                                'types': {'clientData': 'void',
                                                                          'func': ('MMessage',
                                                                                   'MCameraLayerFunction')}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                        'pymelEnums': {}},
  'MColor': {'enums': {'MColorType': {'valueDocs': {'CMY': 'Cyan, Magenta, Yellow.',
                                                    'CMYK': 'Cyan, Magenta, Yellow, Black.',
                                                    'HSV': 'Hue, Saturation, Value.',
                                                    'RGB': 'Red, Green, Blue.',
                                                    'kCMY': 'Cyan, Magenta, Yellow.',
                                                    'kCMYK': 'Cyan, Magenta, Yellow, Black.',
                                                    'kHSV': 'Hue, Saturation, Value.',
                                                    'kRGB': 'Red, Green, Blue.'},
                                      'values': "Enum('MColorType', {'kRGB': 0, 'kHSV': 1, 'kCMY': 2, 'kCMYK': 3})"}},
             'methods': {'__add__': [{'argInfo': {'other': {'doc': 'Color to be added to this color.',
                                                            'type': 'MColor'}},
                                      'args': [('other', 'MColor', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nAdd operator. \r\n',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A new MColor object representing the sum of this color and the specified color. ',
                                                     'qualifiers': [],
                                                     'type': 'MColor'},
                                      'returnType': 'MColor',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MColor'}}],
                         '__div__': [{'argInfo': {'scalar': {'doc': 'Color division factor.',
                                                             'type': 'float'}},
                                      'args': [('scalar', 'float', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nDivide operator. \r\n',
                                      'inArgs': ['scalar'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A new MColor object representing the color divided by the scalar. ',
                                                     'qualifiers': [],
                                                     'type': 'MColor'},
                                      'returnType': 'MColor',
                                      'static': False,
                                      'typeQualifiers': {'scalar': []},
                                      'types': {'scalar': 'float'}}],
                         '__eq__': [{'argInfo': {'other': {'doc': 'Color to which this color will be compared.',
                                                           'type': 'MColor'}},
                                     'args': [('other', 'MColor', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nEquality operator. \r\n',
                                     'inArgs': ['other'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'A bool value:  true if the colors are identical  false otherwise   ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'other': ['const',
                                                                  '&']},
                                     'types': {'other': 'MColor'}}],
                         '__getitem__': [{'argInfo': {'i': {'doc': 'Value indicating which component to return.',
                                                            'type': 'uint'}},
                                          'args': [('i', 'uint', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nIndex operator. \r\n',
                                          'inArgs': ['i'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A reference to the appropriate component of the color:  Reference to the red channel when argument is 0.  Reference to the green channel when argument is 1.  Reference to the blue channel when argument is 2.  Reference to the alpha channel otherwise.   ',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': False,
                                          'typeQualifiers': {'i': ['unsigned']},
                                          'types': {'i': 'uint'}},
                                         {'argInfo': {'i': {'doc': 'Value indicating which component to return.',
                                                            'type': 'uint'}},
                                          'args': [('i', 'uint', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nIndex operator. NO SCRIPT SUPPORT. \r\n',
                                          'inArgs': ['i'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A reference to the appropriate component of the color:  Reference to the red channel when argument is 0.  Reference to the green channel when argument is 1.  Reference to the blue channel when argument is 2.  Reference to the alpha channel otherwise.   ',
                                                         'qualifiers': ['&'],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': False,
                                          'typeQualifiers': {'i': ['unsigned']},
                                          'types': {'i': 'uint'}}],
                         '__iadd__': [{'argInfo': {'other': {'doc': 'Color to be added to this color.',
                                                             'type': 'MColor'}},
                                       'args': [('other',
                                                 'MColor',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nIn place add operator. \r\n',
                                       'inArgs': ['other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A reference to the color whose value was modified. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MColor'},
                                       'returnType': 'MColor',
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&']},
                                       'types': {'other': 'MColor'}}],
                         '__idiv__': [{'argInfo': {'scalar': {'doc': 'Color division factor.',
                                                              'type': 'float'}},
                                       'args': [('scalar',
                                                 'float',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nIn place divide operator. \r\n',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A reference to the color whose value was modified. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MColor'},
                                       'returnType': 'MColor',
                                       'static': False,
                                       'typeQualifiers': {'scalar': []},
                                       'types': {'scalar': 'float'}}],
                         '__imul__': [{'argInfo': {'scalar': {'doc': 'Color multiplication factor.',
                                                              'type': 'float'}},
                                       'args': [('scalar',
                                                 'float',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nIn place multiply operator. \r\n',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A reference to the color object which was modified. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MColor'},
                                       'returnType': 'MColor',
                                       'static': False,
                                       'typeQualifiers': {'scalar': []},
                                       'types': {'scalar': 'float'}},
                                      {'argInfo': {'other': {'doc': 'Color to be multiplied with this color.',
                                                             'type': 'MColor'}},
                                       'args': [('other',
                                                 'MColor',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nIn place multiply operator. \r\n',
                                       'inArgs': ['other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A reference to the color whose value was modified. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MColor'},
                                       'returnType': 'MColor',
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&']},
                                       'types': {'other': 'MColor'}}],
                         '__mul__': [{'argInfo': {'scalar': {'doc': 'Color multiplication factor.',
                                                             'type': 'float'}},
                                      'args': [('scalar', 'float', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nMultiply operator. \r\n',
                                      'inArgs': ['scalar'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A new MColor object representing the product of the original MColor with the scalar value. ',
                                                     'qualifiers': [],
                                                     'type': 'MColor'},
                                      'returnType': 'MColor',
                                      'static': False,
                                      'typeQualifiers': {'scalar': []},
                                      'types': {'scalar': 'float'}},
                                     {'argInfo': {'other': {'doc': 'Color to be multiplied with this color.',
                                                            'type': 'MColor'}},
                                      'args': [('other', 'MColor', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nMultiply operator. \r\n',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A new MColor object representing the product of the two colors. ',
                                                     'qualifiers': [],
                                                     'type': 'MColor'},
                                      'returnType': 'MColor',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MColor'}},
                                     {'argInfo': {'other': {'doc': 'Color object to be multiplied.',
                                                            'type': 'MColor'},
                                                  'scalar': {'doc': 'Color multiplication factor. ',
                                                             'type': 'float'}},
                                      'args': [('scalar', 'float', 'in'),
                                               ('other', 'MColor', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nMultiply operator. NO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['scalar', 'other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A new MColor object representing the product of the specified scalar and color. ',
                                                     'qualifiers': ['MColor'],
                                                     'type': ('MColor',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MColor',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&'],
                                                         'scalar': []},
                                      'types': {'other': 'MColor',
                                                'scalar': 'float'}}],
                         '__ne__': [{'argInfo': {'other': {'doc': 'Color to which this color will be compared.',
                                                           'type': 'MColor'}},
                                     'args': [('other', 'MColor', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nInequality operator. \r\n',
                                     'inArgs': ['other'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'A bool value:  false if the colors are identical  true otherwise   ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'other': ['const',
                                                                  '&']},
                                     'types': {'other': 'MColor'}}],
                         '__sub__': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nUnary minus operator. \r\n',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'MColor'},
                                      'returnType': 'MColor',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}},
                                     {'argInfo': {'other': {'doc': 'Color to be subtracted from this color.',
                                                            'type': 'MColor'}},
                                      'args': [('other', 'MColor', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSubstraction operator. \r\n',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A new MColor object representing this color minus the specified other color. ',
                                                     'qualifiers': [],
                                                     'type': 'MColor'},
                                      'returnType': 'MColor',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MColor'}}],
                         'get': [{'argInfo': {'d': {'doc': 'The array of 3 floats into which the results are placed.',
                                                    'type': 'float__array3'}},
                                  'args': [('d', 'float__array3', 'out')],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nColor component accessor. \r\n',
                                  'inArgs': [],
                                  'outArgs': ['d'],
                                  'returnInfo': {'doc': 'Always returns bool true. ',
                                                 'qualifiers': [],
                                                 'type': 'bool'},
                                  'returnType': 'bool',
                                  'static': False,
                                  'typeQualifiers': {'d': []},
                                  'types': {'d': 'float__array3'}},
                                 {'argInfo': {'c1': {'doc': 'Storage for the first component of color. ',
                                                     'type': 'float'},
                                              'c2': {'doc': 'Storage for the second component of color. ',
                                                     'type': 'float'},
                                              'c3': {'doc': 'Storage for the third component of color.',
                                                     'type': 'float'},
                                              'colorModel': {'doc': 'The color model. ',
                                                             'type': ('MColor',
                                                                      'MColorType')}},
                                  'args': [('colorModel',
                                            ('MColor', 'MColorType'),
                                            'in'),
                                           ('c1', 'float', 'out'),
                                           ('c2', 'float', 'out'),
                                           ('c3', 'float', 'out')],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nColor component accessor. \r\n',
                                  'inArgs': ['colorModel'],
                                  'outArgs': ['c1', 'c2', 'c3'],
                                  'returnInfo': {'doc': 'Always returns bool true. ',
                                                 'qualifiers': [],
                                                 'type': 'bool'},
                                  'returnType': 'bool',
                                  'static': False,
                                  'typeQualifiers': {'c1': ['&'],
                                                     'c2': ['&'],
                                                     'c3': ['&'],
                                                     'colorModel': []},
                                  'types': {'c1': 'float',
                                            'c2': 'float',
                                            'c3': 'float',
                                            'colorModel': ('MColor',
                                                           'MColorType')}},
                                 {'argInfo': {'alpha': {'doc': 'Storage for the alpha component of color.',
                                                        'type': 'float'},
                                              'c1': {'doc': 'Storage for the first component of color. ',
                                                     'type': 'float'},
                                              'c2': {'doc': 'Storage for the second component of color. ',
                                                     'type': 'float'},
                                              'c3': {'doc': 'Storage for the third component of color. ',
                                                     'type': 'float'},
                                              'colorModel': {'doc': 'The color model. ',
                                                             'type': ('MColor',
                                                                      'MColorType')}},
                                  'args': [('colorModel',
                                            ('MColor', 'MColorType'),
                                            'in'),
                                           ('c1', 'float', 'out'),
                                           ('c2', 'float', 'out'),
                                           ('c3', 'float', 'out'),
                                           ('alpha', 'float', 'out')],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nColor component accessor. \r\n',
                                  'inArgs': ['colorModel'],
                                  'outArgs': ['c1', 'c2', 'c3', 'alpha'],
                                  'returnInfo': {'doc': 'Always returns bool true. ',
                                                 'qualifiers': [],
                                                 'type': 'bool'},
                                  'returnType': 'bool',
                                  'static': False,
                                  'typeQualifiers': {'alpha': ['&'],
                                                     'c1': ['&'],
                                                     'c2': ['&'],
                                                     'c3': ['&'],
                                                     'colorModel': []},
                                  'types': {'alpha': 'float',
                                            'c1': 'float',
                                            'c2': 'float',
                                            'c3': 'float',
                                            'colorModel': ('MColor',
                                                           'MColorType')}}],
                         'set': [{'argInfo': {'alpha': {'doc': 'Alpha component of color.',
                                                        'type': 'float'},
                                              'c1': {'doc': 'First component of color. ',
                                                     'type': 'float'},
                                              'c2': {'doc': 'Second component of color. ',
                                                     'type': 'float'},
                                              'c3': {'doc': 'Third component of color. ',
                                                     'type': 'float'},
                                              'colorModel': {'doc': 'The color model. ',
                                                             'type': ('MColor',
                                                                      'MColorType')}},
                                  'args': [('colorModel',
                                            ('MColor', 'MColorType'),
                                            'in'),
                                           ('c1', 'float', 'in'),
                                           ('c2', 'float', 'in'),
                                           ('c3', 'float', 'in'),
                                           ('alpha', 'float', 'in')],
                                  'defaults': {'alpha': 1.0},
                                  'deprecated': False,
                                  'doc': '\r\nColor component assigment. \r\n',
                                  'inArgs': ['colorModel',
                                             'c1',
                                             'c2',
                                             'c3',
                                             'alpha'],
                                  'outArgs': [],
                                  'returnInfo': {'doc': 'Always returns bool true. ',
                                                 'qualifiers': [],
                                                 'type': 'bool'},
                                  'returnType': 'bool',
                                  'static': False,
                                  'typeQualifiers': {'alpha': [],
                                                     'c1': [],
                                                     'c2': [],
                                                     'c3': [],
                                                     'colorModel': []},
                                  'types': {'alpha': 'float',
                                            'c1': 'float',
                                            'c2': 'float',
                                            'c3': 'float',
                                            'colorModel': ('MColor',
                                                           'MColorType')}}]},
             'pymelEnums': {'MColorType': "Enum('MColorType', [('RGB', 0), ('kRGB', 0), ('HSV', 1), ('kHSV', 1), ('CMY', 2), ('kCMY', 2), ('CMYK', 3), ('kCMYK', 3)], multiKeys=True)"}},
  'MColorArray': {'enums': {},
                  'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                  ('setLength', 'length')],
                  'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the indicated element. ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MColor'},
                                               'returnType': 'MColor',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}},
                                              {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the indicated element ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MColor'},
                                               'returnType': 'MColor',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                              'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                  'type': 'MColor'}},
                                          'args': [('element',
                                                    'MColor',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': ['const',
                                                                         '&']},
                                          'types': {'element': 'MColor'}},
                                         {'argInfo': {'w': {'doc': 'the value for the w component, defaulted to 1',
                                                            'type': 'float'},
                                                      'x': {'doc': 'the value for the x component ',
                                                            'type': 'float'},
                                                      'y': {'doc': 'the value for the y component ',
                                                            'type': 'float'},
                                                      'z': {'doc': 'the value for the z component, defaulted to 0 ',
                                                            'type': 'float'}},
                                          'args': [('x', 'float', 'in'),
                                                   ('y', 'float', 'in'),
                                                   ('z', 'float', 'in'),
                                                   ('w', 'float', 'in')],
                                          'defaults': {'w': 1.0},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new element to the end of the array. The appended element has the indicated values for its x,y,z and w components. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.',
                                          'inArgs': ['x', 'y', 'z', 'w'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'w': [],
                                                             'x': [],
                                                             'y': [],
                                                             'z': []},
                                          'types': {'w': 'float',
                                                    'x': 'float',
                                                    'y': 'float',
                                                    'z': 'float'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'clear': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                               'type': 'MColorArray'}},
                                        'args': [('source',
                                                  'MColorArray',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopy the contents of the source array to this array.',
                                        'inArgs': ['source'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'source': ['const',
                                                                      '&']},
                                        'types': {'source': 'MColorArray'}}],
                              'get': [{'argInfo': {'dest': {'doc': 'the array to populate',
                                                            'type': 'float__array'}},
                                       'args': [('dest',
                                                 'float__array',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the elements of the array into the C++ array of float arrays. No checking is done to ensure that the destination C++ array of float arrays is large enough to hold all the elements of the instance.',
                                       'inArgs': [],
                                       'outArgs': ['dest'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'dest': []},
                                       'types': {'dest': 'float__array'}}],
                              'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                  'type': 'MColor'},
                                                      'index': {'doc': 'the index of the element to set to the the new value',
                                                                'type': 'uint'}},
                                          'args': [('element',
                                                    'MColor',
                                                    'in'),
                                                   ('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element', 'index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': ['const',
                                                                         '&'],
                                                             'index': ['unsigned']},
                                          'types': {'element': 'MColor',
                                                    'index': 'uint'}}],
                              'length': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the number of elements in the instance.',
                                          'inArgs': [],
                                          'inverse': ('setLength', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The number of elements in the instance ',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                'type': 'uint'}},
                                          'args': [('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                          'inArgs': ['index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'index': ['unsigned']},
                                          'types': {'index': 'uint'}}],
                              'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                               'type': 'MColor'},
                                                   'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'}},
                                       'args': [('element',
                                                 'MColor',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated value.',
                                       'inArgs': ['element', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'element': ['const',
                                                                      '&'],
                                                          'index': ['unsigned']},
                                       'types': {'element': 'MColor',
                                                 'index': 'uint'}},
                                      {'argInfo': {'a': {'doc': 'the new value for the a component,defaulted to 1',
                                                         'type': 'float'},
                                                   'b': {'doc': 'the new value for the b component ',
                                                         'type': 'float'},
                                                   'g': {'doc': 'the new value for the g component ',
                                                         'type': 'float'},
                                                   'index': {'doc': 'the index of the element that is to be set to the the new value ',
                                                             'type': 'uint'},
                                                   'r': {'doc': 'the new value for the r component ',
                                                         'type': 'float'}},
                                       'args': [('index', 'uint', 'in'),
                                                ('r', 'float', 'in'),
                                                ('g', 'float', 'in'),
                                                ('b', 'float', 'in'),
                                                ('a', 'float', 'in')],
                                       'defaults': {'a': 1.0},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated values. The r component of the element is set to r, the g component to g, the b component to b, and the a component to a.',
                                       'inArgs': ['index',
                                                  'r',
                                                  'g',
                                                  'b',
                                                  'a'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'a': [],
                                                          'b': [],
                                                          'g': [],
                                                          'index': ['unsigned'],
                                                          'r': []},
                                       'types': {'a': 'float',
                                                 'b': 'float',
                                                 'g': 'float',
                                                 'index': 'uint',
                                                 'r': 'float'}},
                                      {'argInfo': {'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'},
                                                   'val': {'doc': 'the new value for the indicated element ',
                                                           'type': 'float__array4'}},
                                       'args': [('val',
                                                 'float__array4',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated value. The r component of the element is set to val[0], the g component to val[1], the b component to val[2], and the a component to val[3].',
                                       'inArgs': ['val', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'index': ['unsigned'],
                                                          'val': []},
                                       'types': {'index': 'uint',
                                                 'val': 'float__array4'}},
                                      {'argInfo': {'elements': {'doc': 'C++ array of float arrays of length four. ',
                                                                'type': 'float__array'},
                                                   'size': {'doc': 'the number of elements in the array.',
                                                            'type': 'uint'}},
                                       'args': [('elements',
                                                 'float__array',
                                                 'in'),
                                                ('size', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nResets the values of the color components. The length of the passed in C++ array should be same as the length of the ColorArray to which we are setting the values.',
                                       'inArgs': ['elements', 'size'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'elements': [],
                                                          'size': ['unsigned']},
                                       'types': {'elements': 'float__array',
                                                 'size': 'uint'}},
                                      {'argInfo': {'elements': {'doc': 'C++ array of double arrays of length four. ',
                                                                'type': 'double__array'},
                                                   'size': {'doc': 'the number of elements in the array.',
                                                            'type': 'uint'}},
                                       'args': [('elements',
                                                 'double__array',
                                                 'in'),
                                                ('size', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nResets the values of the color components. The length of the passed in C++ array should be same as the length of the ColorArray to which we are setting the values.',
                                       'inArgs': ['elements', 'size'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'elements': [],
                                                          'size': ['unsigned']},
                                       'types': {'elements': 'double__array',
                                                 'size': 'uint'}}],
                              'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array',
                                                                    'type': 'uint'}},
                                             'args': [('length',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                             'inArgs': ['length'],
                                             'inverse': ('length', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'length': ['unsigned']},
                                             'types': {'length': 'uint'}}],
                              'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                 'type': 'uint'}},
                                                    'args': [('newIncrement',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                    'inArgs': ['newIncrement'],
                                                    'inverse': ('sizeIncrement',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'newIncrement': ['unsigned']},
                                                    'types': {'newIncrement': 'uint'}}],
                              'sizeIncrement': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                 'inArgs': [],
                                                 'inverse': ('setSizeIncrement',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'length': 'getLength',
                                   'sizeIncrement': 'getSizeIncrement'}},
  'MCommandMessage': {'enums': {'MessageType': {'valueDocs': {'display': 'String to display unmodified.',
                                                              'error': 'Error message.',
                                                              'history': 'Command history.',
                                                              'info': 'General information.',
                                                              'kDisplay': 'String to display unmodified.',
                                                              'kError': 'Error message.',
                                                              'kHistory': 'Command history.',
                                                              'kInfo': 'General information.',
                                                              'kResult': 'Result from a command execution in the command window.',
                                                              'kStackTrace': 'Stack trace.',
                                                              'kWarning': 'Warning message.',
                                                              'result': 'Result from a command execution in the command window.',
                                                              'stackTrace': 'Stack trace.',
                                                              'warning': 'Warning message.'},
                                                'values': "Enum('MessageType', {'kHistory': 0, 'kDisplay': 1, 'kInfo': 2, 'kWarning': 3, 'kError': 4, 'kResult': 5, 'kStackTrace': 6})"}},
                      'methods': {'addCommandCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function. ',
                                                                                     'type': 'void'},
                                                                      'func': {'doc': 'The callback function. ',
                                                                               'type': ('MMessage',
                                                                                        'MStringFunction')}},
                                                          'args': [('func',
                                                                    ('MMessage',
                                                                     'MStringFunction'),
                                                                    'in'),
                                                                   ('clientData',
                                                                    'void',
                                                                    'in')],
                                                          'defaults': {'clientData': None},
                                                          'deprecated': False,
                                                          'doc': '\nThis method registers a callback for command messages that are issued every time a MEL command is executed. It is only called when actual commands are executed and not when scripts are executed.',
                                                          'inArgs': ['func',
                                                                     'clientData'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                         'qualifiers': [],
                                                                         'type': 'MCallbackId'},
                                                          'returnType': 'MCallbackId',
                                                          'static': True,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'clientData': ['*'],
                                                                             'func': []},
                                                          'types': {'clientData': 'void',
                                                                    'func': ('MMessage',
                                                                             'MStringFunction')}}],
                                  'addCommandOutputCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function. ',
                                                                                           'type': 'void'},
                                                                            'func': {'doc': 'The callback function. ',
                                                                                     'type': ('MCommandMessage',
                                                                                              'MMessageFunction')}},
                                                                'args': [('func',
                                                                          ('MCommandMessage',
                                                                           'MMessageFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': '\nThis method registers a callback for whenever commands generate output such as that which is printed into the command window.',
                                                                'inArgs': ['func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'func': []},
                                                                'types': {'clientData': 'void',
                                                                          'func': ('MCommandMessage',
                                                                                   'MMessageFunction')}}],
                                  'addCommandOutputFilterCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function. ',
                                                                                                 'type': 'void'},
                                                                                  'func': {'doc': 'The callback function. ',
                                                                                           'type': ('MCommandMessage',
                                                                                                    'MMessageFilterFunction')}},
                                                                      'args': [('func',
                                                                                ('MCommandMessage',
                                                                                 'MMessageFilterFunction'),
                                                                                'in'),
                                                                               ('clientData',
                                                                                'void',
                                                                                'in')],
                                                                      'defaults': {'clientData': None},
                                                                      'deprecated': False,
                                                                      'doc': '\nThis method registers a callback for whenever commands generate output such as that which is printed into the command window.',
                                                                      'inArgs': ['func',
                                                                                 'clientData'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                     'qualifiers': [],
                                                                                     'type': 'MCallbackId'},
                                                                      'returnType': 'MCallbackId',
                                                                      'static': True,
                                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                         'clientData': ['*'],
                                                                                         'func': []},
                                                                      'types': {'clientData': 'void',
                                                                                'func': ('MCommandMessage',
                                                                                         'MMessageFilterFunction')}}],
                                  'addProcCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function. ',
                                                                                  'type': 'void'},
                                                                   'func': {'doc': 'The callback function. ',
                                                                            'type': ('MMessage',
                                                                                     'MStringIntBoolIntFunction')}},
                                                       'args': [('func',
                                                                 ('MMessage',
                                                                  'MStringIntBoolIntFunction'),
                                                                 'in'),
                                                                ('clientData',
                                                                 'void',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nThis method registers a callback that is executed every time a MEL procedure is run. The callback will be executed once when the procedure is about to be executed, and again when it has exited. If a non-existent procedure is called the callback will be called once for entry but there will be no call on exit.',
                                                       'inArgs': ['func',
                                                                  'clientData'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                      'qualifiers': [],
                                                                      'type': 'MCallbackId'},
                                                       'returnType': 'MCallbackId',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'clientData': ['*'],
                                                                          'func': []},
                                                       'types': {'clientData': 'void',
                                                                 'func': ('MMessage',
                                                                          'MStringIntBoolIntFunction')}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                      'pymelEnums': {'MessageType': "Enum('MessageType', [('history', 0), ('kHistory', 0), ('display', 1), ('kDisplay', 1), ('info', 2), ('kInfo', 2), ('warning', 3), ('kWarning', 3), ('error', 4), ('kError', 4), ('result', 5), ('kResult', 5), ('stackTrace', 6), ('kStackTrace', 6)], multiKeys=True)"}},
  'MCommandResult': {'enums': {'Type': {'valueDocs': {'double': '',
                                                      'doubleArray': '',
                                                      'int': '',
                                                      'int64': '',
                                                      'int64Array': '',
                                                      'intArray': '',
                                                      'invalid': '',
                                                      'kDouble': '',
                                                      'kDoubleArray': '',
                                                      'kInt': '',
                                                      'kInt64': '',
                                                      'kInt64Array': '',
                                                      'kIntArray': '',
                                                      'kInvalid': '',
                                                      'kMatrix': '',
                                                      'kMatrixArray': '',
                                                      'kString': '',
                                                      'kStringArray': '',
                                                      'kVector': '',
                                                      'kVectorArray': '',
                                                      'matrix': '',
                                                      'matrixArray': '',
                                                      'string': '',
                                                      'stringArray': '',
                                                      'vector': '',
                                                      'vectorArray': ''},
                                        'values': "Enum('Type', {'kInvalid': 0, 'kInt': 1, 'kInt64': 2, 'kIntArray': 3, 'kInt64Array': 4, 'kDouble': 5, 'kDoubleArray': 6, 'kString': 7, 'kStringArray': 8, 'kVector': 9, 'kVectorArray': 10, 'kMatrix': 11, 'kMatrixArray': 12})"}},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'getResult': [{'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'int'}},
                                                'args': [('result',
                                                          'int',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves an integer result as a 32-bit int. Results too big to fit in a 32-bit int will be truncated to their least significant 32 bits.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'int'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MInt64'}},
                                                'args': [('result',
                                                          'MInt64',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves an integer command result as a 64-bit int.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MInt64'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MIntArray'}},
                                                'args': [('result',
                                                          'MIntArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is an int array.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MIntArray'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MInt64Array'}},
                                                'args': [('result',
                                                          'MInt64Array',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is an  MInt64Array .',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MInt64Array'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'double'}},
                                                'args': [('result',
                                                          'double',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is a double.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'double'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MDoubleArray'}},
                                                'args': [('result',
                                                          'MDoubleArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is a double array.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MDoubleArray'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MString'}},
                                                'args': [('result',
                                                          'MString',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nNO SCRIPT SUPPORT. \n',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MString'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MStringArray'}},
                                                'args': [('result',
                                                          'MStringArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is a string array.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MStringArray'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MVector'}},
                                                'args': [('result',
                                                          'MVector',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is a vector.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MVector'}},
                                               {'argInfo': {'result': {'doc': 'Storage for the command result',
                                                                       'type': 'MVectorArray'}},
                                                'args': [('result',
                                                          'MVectorArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is a vector array.',
                                                'inArgs': [],
                                                'outArgs': ['result'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'result': ['&']},
                                                'types': {'result': 'MVectorArray'}},
                                               {'argInfo': {'numColumns': {'doc': 'The number of columns in the matrix',
                                                                           'type': 'int'},
                                                            'numRows': {'doc': 'The number of rows in the matrix ',
                                                                        'type': 'int'},
                                                            'result': {'doc': 'Storage for the content of the matrix (row-based) ',
                                                                       'type': 'MDoubleArray'}},
                                                'args': [('result',
                                                          'MDoubleArray',
                                                          'out'),
                                                         ('numRows',
                                                          'int',
                                                          'out'),
                                                         ('numColumns',
                                                          'int',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRetrieves the command result which is a matrix.',
                                                'inArgs': [],
                                                'outArgs': ['result',
                                                            'numRows',
                                                            'numColumns'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'numColumns': ['&'],
                                                                   'numRows': ['&'],
                                                                   'result': ['&']},
                                                'types': {'numColumns': 'int',
                                                          'numRows': 'int',
                                                          'result': 'MDoubleArray'}}],
                                 'resultType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the type of the result.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' MCommandResult::kInt  MCommandResult::kIntArray  MCommandResult::kDouble  MCommandResult::kDoubleArray  MCommandResult::kString  MCommandResult::kStringArray  MCommandResult::kVector  MCommandResult::kVectorArray  MCommandResult::kMatrix  MCommandResult::kInvalid   ',
                                                                'qualifiers': [],
                                                                'type': ('MCommandResult',
                                                                         'Type')},
                                                 'returnType': ('MCommandResult',
                                                                'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                 'stringResult': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nRetrieves the command result which is a string.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The command result',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}]},
                     'pymelEnums': {'Type': "Enum('Type', [('invalid', 0), ('kInvalid', 0), ('int', 1), ('kInt', 1), ('int64', 2), ('kInt64', 2), ('intArray', 3), ('kIntArray', 3), ('int64Array', 4), ('kInt64Array', 4), ('double', 5), ('kDouble', 5), ('doubleArray', 6), ('kDoubleArray', 6), ('string', 7), ('kString', 7), ('stringArray', 8), ('kStringArray', 8), ('vector', 9), ('kVector', 9), ('vectorArray', 10), ('kVectorArray', 10), ('matrix', 11), ('kMatrix', 11), ('matrixArray', 12), ('kMatrixArray', 12)], multiKeys=True)"}},
  'MCommonRenderSettingsData': {'enums': {'MpathType': {'valueDocs': {'fullPathImage': 'Full path.',
                                                                      'fullPathTmp': 'Full path in the temporary directory.',
                                                                      'kFullPathImage': 'Full path.',
                                                                      'kFullPathTmp': 'Full path in the temporary directory.',
                                                                      'kRelativePath': 'Relative to the project.',
                                                                      'relativePath': 'Relative to the project.'},
                                                        'values': "Enum('MpathType', {'kRelativePath': 0, 'kFullPathImage': 1, 'kFullPathTmp': 2})"}},
                                'methods': {'className': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturns the name of this class.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'getBufferName': [{'argInfo': {'cameraName': {'doc': 'The name of the camera rendering this image. ',
                                                                                          'type': 'MString'},
                                                                           'customTokenString': {'doc': 'Space separated list of key-value pairs to replace in the buffer name (ex. "myToken1=myValue1 myToken2=myValue2"). ',
                                                                                                 'type': 'MString'},
                                                                           'layer': {'doc': 'render layer object pointer from which this image is rendered. ',
                                                                                     'type': 'MObject'},
                                                                           'leaveUnmatchedTokens': {'doc': 'whether to leave the unmatched tokens. ',
                                                                                                    'type': 'bool'},
                                                                           'renderPass': {'doc': 'Render pass object of the this rendering image. ',
                                                                                          'type': 'MObject'}},
                                                               'args': [('renderPass',
                                                                         'MObject',
                                                                         'in'),
                                                                        ('layer',
                                                                         'MObject',
                                                                         'in'),
                                                                        ('cameraName',
                                                                         'MString',
                                                                         'in'),
                                                                        ('customTokenString',
                                                                         'MString',
                                                                         'in'),
                                                                        ('leaveUnmatchedTokens',
                                                                         'bool',
                                                                         'in')],
                                                               'defaults': {'customTokenString': '""',
                                                                            'leaveUnmatchedTokens': False},
                                                               'deprecated': False,
                                                               'doc': '\nGet image buffer name',
                                                               'inArgs': ['renderPass',
                                                                          'layer',
                                                                          'cameraName',
                                                                          'customTokenString',
                                                                          'leaveUnmatchedTokens'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The name of buffer as a string. ',
                                                                              'qualifiers': [],
                                                                              'type': 'MString'},
                                                               'returnType': 'MString',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'cameraName': ['const',
                                                                                                 '&'],
                                                                                  'customTokenString': ['const',
                                                                                                        '&'],
                                                                                  'layer': ['const',
                                                                                            '&'],
                                                                                  'leaveUnmatchedTokens': ['const'],
                                                                                  'renderPass': ['const',
                                                                                                 '&']},
                                                               'types': {'cameraName': 'MString',
                                                                         'customTokenString': 'MString',
                                                                         'layer': 'MObject',
                                                                         'leaveUnmatchedTokens': 'bool',
                                                                         'renderPass': 'MObject'}}],
                                            'getImageName': [{'argInfo': {'cameraName': {'doc': 'the name of the camera rendering this image. ',
                                                                                         'type': 'MString'},
                                                                          'createDirectory': {'doc': 'if true, the image path directory will be created. ',
                                                                                              'type': 'bool'},
                                                                          'fileFormat': {'doc': 'if not an empty string, use this file format instead of the one selected in the render settings to decide the final file name. ',
                                                                                         'type': 'MString'},
                                                                          'frameNumber': {'doc': 'the frame number to be used. ',
                                                                                          'type': 'double'},
                                                                          'layer': {'doc': 'render layer object from which this image is rendered. ',
                                                                                    'type': 'MObject'},
                                                                          'pathType': {'doc': 'decides file path format of the returned string. See above. ',
                                                                                       'type': ('MCommonRenderSettingsData',
                                                                                                'MpathType')},
                                                                          'sceneName': {'doc': 'the scene name. ',
                                                                                        'type': 'MString'}},
                                                              'args': [('pathType',
                                                                        ('MCommonRenderSettingsData',
                                                                         'MpathType'),
                                                                        'in'),
                                                                       ('frameNumber',
                                                                        'double',
                                                                        'in'),
                                                                       ('sceneName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('cameraName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('fileFormat',
                                                                        'MString',
                                                                        'in'),
                                                                       ('layer',
                                                                        'MObject',
                                                                        'in'),
                                                                       ('createDirectory',
                                                                        'bool',
                                                                        'in')],
                                                              'defaults': {'createDirectory': True},
                                                              'deprecated': False,
                                                              'doc': '\nObtains the image name with the proper subdirectory structure. \n',
                                                              'inArgs': ['pathType',
                                                                         'frameNumber',
                                                                         'sceneName',
                                                                         'cameraName',
                                                                         'fileFormat',
                                                                         'layer',
                                                                         'createDirectory'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The image path as a string. ',
                                                                             'qualifiers': [],
                                                                             'type': 'MString'},
                                                              'returnType': 'MString',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'cameraName': ['const',
                                                                                                '&'],
                                                                                 'createDirectory': ['const'],
                                                                                 'fileFormat': ['const',
                                                                                                '&'],
                                                                                 'frameNumber': [],
                                                                                 'layer': ['const'],
                                                                                 'pathType': [],
                                                                                 'sceneName': ['const',
                                                                                               '&']},
                                                              'types': {'cameraName': 'MString',
                                                                        'createDirectory': 'bool',
                                                                        'fileFormat': 'MString',
                                                                        'frameNumber': 'double',
                                                                        'layer': 'MObject',
                                                                        'pathType': ('MCommonRenderSettingsData',
                                                                                     'MpathType'),
                                                                        'sceneName': 'MString'}},
                                                             {'argInfo': {'cameraName': {'doc': 'the name of the camera rendering this image. ',
                                                                                         'type': 'MString'},
                                                                          'createDirectory': {'doc': 'if true, the image path directory will be created. ',
                                                                                              'type': 'bool'},
                                                                          'customTokenString': {'doc': 'space separated list of key-value pairs to replace in the image name (ex. "myToken1=myValue1 myToken2=myValue2") ',
                                                                                                'type': 'MString'},
                                                                          'fileFormat': {'doc': 'if not an empty string, use this file format instead of the one selected in the render settings to decide the final file name. ',
                                                                                         'type': 'MString'},
                                                                          'frameNumber': {'doc': 'the frame number to be used. ',
                                                                                          'type': 'double'},
                                                                          'layer': {'doc': 'render layer object from which this image is rendered. ',
                                                                                    'type': 'MObject'},
                                                                          'pathType': {'doc': 'decides file path format of the returned string. See above. ',
                                                                                       'type': ('MCommonRenderSettingsData',
                                                                                                'MpathType')},
                                                                          'sceneName': {'doc': 'the scene name. ',
                                                                                        'type': 'MString'}},
                                                              'args': [('pathType',
                                                                        ('MCommonRenderSettingsData',
                                                                         'MpathType'),
                                                                        'in'),
                                                                       ('frameNumber',
                                                                        'double',
                                                                        'in'),
                                                                       ('sceneName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('cameraName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('fileFormat',
                                                                        'MString',
                                                                        'in'),
                                                                       ('layer',
                                                                        'MObject',
                                                                        'in'),
                                                                       ('customTokenString',
                                                                        'MString',
                                                                        'in'),
                                                                       ('createDirectory',
                                                                        'bool',
                                                                        'in')],
                                                              'defaults': {'createDirectory': True},
                                                              'deprecated': False,
                                                              'doc': '\nObtains the image name with the proper subdirectory structure (supports custom tokens). \n',
                                                              'inArgs': ['pathType',
                                                                         'frameNumber',
                                                                         'sceneName',
                                                                         'cameraName',
                                                                         'fileFormat',
                                                                         'layer',
                                                                         'customTokenString',
                                                                         'createDirectory'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The image path as a string. ',
                                                                             'qualifiers': [],
                                                                             'type': 'MString'},
                                                              'returnType': 'MString',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'cameraName': ['const',
                                                                                                '&'],
                                                                                 'createDirectory': ['const'],
                                                                                 'customTokenString': ['const',
                                                                                                       '&'],
                                                                                 'fileFormat': ['const',
                                                                                                '&'],
                                                                                 'frameNumber': [],
                                                                                 'layer': ['const'],
                                                                                 'pathType': [],
                                                                                 'sceneName': ['const',
                                                                                               '&']},
                                                              'types': {'cameraName': 'MString',
                                                                        'createDirectory': 'bool',
                                                                        'customTokenString': 'MString',
                                                                        'fileFormat': 'MString',
                                                                        'frameNumber': 'double',
                                                                        'layer': 'MObject',
                                                                        'pathType': ('MCommonRenderSettingsData',
                                                                                     'MpathType'),
                                                                        'sceneName': 'MString'}}],
                                            'getPostRenderFrameCmd': [{'argInfo': {},
                                                                       'args': [],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\nReturn the postRenderFrame MEL command, which is run immediately after rendering a frame. It is run after the configurable postRenderMel string. This command is guaranteed to be a non-empty string.',
                                                                       'inArgs': [],
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': 'MString'},
                                                                       'returnType': 'MString',
                                                                       'static': True,
                                                                       'typeQualifiers': {},
                                                                       'types': {}}],
                                            'getPreRenderFrameCmd': [{'argInfo': {},
                                                                      'args': [],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\nReturn the preRenderFrame MEL command, which is run immediately before rendering a frame. It is run before the configurable preRenderMel string. This command is guaranteed to be a non-empty string.',
                                                                      'inArgs': [],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': 'MString'},
                                                                      'returnType': 'MString',
                                                                      'static': True,
                                                                      'typeQualifiers': {},
                                                                      'types': {}}],
                                            'isAnimated': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nDetermines if there is animation. \n',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                            'isMovieFormat': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nDetermines if the output format is a single movie file. \n',
                                                               'inArgs': [],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': 'bool'},
                                                               'returnType': 'bool',
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               'types': {}}],
                                            'setFieldName': [{'argInfo': {'field': {'doc': 'The name of the field. ',
                                                                                    'type': 'MString'}},
                                                              'args': [('field',
                                                                        'MString',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nUsed with getImageName. Sets the field name for later use. \n',
                                                              'inArgs': ['field'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'field': ['const',
                                                                                           '&']},
                                                              'types': {'field': 'MString'}}],
                                            'setPassName': [{'argInfo': {'pass': {'doc': 'The name of the field. ',
                                                                                  'type': 'MString'}},
                                                             'args': [('pass',
                                                                       'MString',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nUsed with getImageName. Sets the pass name for later use. \n',
                                                             'inArgs': ['pass'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'pass': ['const',
                                                                                         '&']},
                                                             'types': {'pass': 'MString'}}],
                                            'shouldRenderFrameAtTime': [{'argInfo': {'cameraName': {'doc': 'the name of the camera rendering this image. ',
                                                                                                    'type': 'MString'},
                                                                                     'customTokenString': {'doc': 'space separated list of key-value pairs to replace in the image name (ex. "myToken1=myValue1 myToken2=myValue2")',
                                                                                                           'type': 'MString'},
                                                                                     'fileFormat': {'doc': 'if not an empty string, use this file format instead of the one selected in the render settings to decide the final file name. ',
                                                                                                    'type': 'MString'},
                                                                                     'frameNumber': {'doc': 'the frame number to be used. ',
                                                                                                     'type': 'double'},
                                                                                     'layer': {'doc': 'render layer object from which this image is rendered. ',
                                                                                               'type': 'MObject'},
                                                                                     'pathType': {'doc': 'decides file path format of the returned string. See above. ',
                                                                                                  'type': ('MCommonRenderSettingsData',
                                                                                                           'MpathType')},
                                                                                     'sceneName': {'doc': 'the scene name. ',
                                                                                                   'type': 'MString'}},
                                                                         'args': [('pathType',
                                                                                   ('MCommonRenderSettingsData',
                                                                                    'MpathType'),
                                                                                   'in'),
                                                                                  ('frameNumber',
                                                                                   'double',
                                                                                   'in'),
                                                                                  ('sceneName',
                                                                                   'MString',
                                                                                   'in'),
                                                                                  ('cameraName',
                                                                                   'MString',
                                                                                   'in'),
                                                                                  ('fileFormat',
                                                                                   'MString',
                                                                                   'in'),
                                                                                  ('layer',
                                                                                   'MObject',
                                                                                   'in'),
                                                                                  ('customTokenString',
                                                                                   'MString',
                                                                                   'in')],
                                                                         'defaults': {},
                                                                         'deprecated': False,
                                                                         'doc': '\nIndicates whether render the frame or not. If true, render it. If false, skip it. \n',
                                                                         'inArgs': ['pathType',
                                                                                    'frameNumber',
                                                                                    'sceneName',
                                                                                    'cameraName',
                                                                                    'fileFormat',
                                                                                    'layer',
                                                                                    'customTokenString'],
                                                                         'outArgs': [],
                                                                         'returnInfo': {'doc': 'Whether to render the frame or not. If true, render it. If false, skip it. ',
                                                                                        'qualifiers': [],
                                                                                        'type': 'bool'},
                                                                         'returnType': 'bool',
                                                                         'static': False,
                                                                         'typeQualifiers': {'cameraName': ['const',
                                                                                                           '&'],
                                                                                            'customTokenString': ['const',
                                                                                                                  '&'],
                                                                                            'fileFormat': ['const',
                                                                                                           '&'],
                                                                                            'frameNumber': [],
                                                                                            'layer': ['const'],
                                                                                            'pathType': [],
                                                                                            'sceneName': ['const',
                                                                                                          '&']},
                                                                         'types': {'cameraName': 'MString',
                                                                                   'customTokenString': 'MString',
                                                                                   'fileFormat': 'MString',
                                                                                   'frameNumber': 'double',
                                                                                   'layer': 'MObject',
                                                                                   'pathType': ('MCommonRenderSettingsData',
                                                                                                'MpathType'),
                                                                                   'sceneName': 'MString'}}]},
                                'pymelEnums': {'MpathType': "Enum('MpathType', [('relativePath', 0), ('kRelativePath', 0), ('fullPathImage', 1), ('kFullPathImage', 1), ('fullPathTmp', 2), ('kFullPathTmp', 2)], multiKeys=True)"}},
  'MComputation': {'enums': {},
                   'invertibles': [('setProgress', 'progress')],
                   'methods': {'beginComputation': [{'argInfo': {'isInterruptable': {'doc': 'ESC can be used in conjunction with the isInterruptRequested() method to stop the computation. In this case setProgressStatus() should not be called. ',
                                                                                     'type': 'bool'},
                                                                 'showProgressBar': {'doc': 'if true a progress bar is displayed ',
                                                                                     'type': 'bool'},
                                                                 'useWaitCursor': {'doc': 'if true, cursor goes busy during computation ',
                                                                                   'type': 'bool'}},
                                                     'args': [('showProgressBar',
                                                               'bool',
                                                               'in'),
                                                              ('isInterruptable',
                                                               'bool',
                                                               'in'),
                                                              ('useWaitCursor',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {'isInterruptable': True,
                                                                  'showProgressBar': False,
                                                                  'useWaitCursor': True},
                                                     'deprecated': False,
                                                     'doc': '\r\nMark the beginning of a long computation. The application will begin looking for user interupts.',
                                                     'inArgs': ['showProgressBar',
                                                                'isInterruptable',
                                                                'useWaitCursor'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'isInterruptable': [],
                                                                        'showProgressBar': [],
                                                                        'useWaitCursor': []},
                                                     'types': {'isInterruptable': 'bool',
                                                               'showProgressBar': 'bool',
                                                               'useWaitCursor': 'bool'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'endComputation': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nMark the ending of a long computation. The application will stop looking for user interupts. \r\n  Reprocessed example  \n Examples: \n \n   \n animInfoCmd.cpp . \n \n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                               'isInterruptRequested': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nQuery whether a user-interrupt has occurred.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'true if an interrupt has occurred ',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                               'progress': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the progress value.',
                                             'inArgs': [],
                                             'inverse': ('setProgress',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Progress value. Returns -1 if query fails.',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'progressMax': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the maximum progress value.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Maximum progress value. Returns -1 if query fails.',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                               'progressMin': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the minimum progress value.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Minimum progress value. Returns -1 if query fails.',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                               'setProgress': [{'argInfo': {'amount': {'doc': 'New progress value',
                                                                       'type': 'int'}},
                                                'args': [('amount',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the progress value.',
                                                'inArgs': ['amount'],
                                                'inverse': ('progress',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'amount': ['const']},
                                                'types': {'amount': 'int'}}],
                               'setProgressRange': [{'argInfo': {'maxValue': {'doc': 'Maximum progress value',
                                                                              'type': 'int'},
                                                                 'minValue': {'doc': 'Minimum progress value ',
                                                                              'type': 'int'}},
                                                     'args': [('minValue',
                                                               'int',
                                                               'in'),
                                                              ('maxValue',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the range (minValue, maxValue) of the progress indicator.',
                                                     'inArgs': ['minValue',
                                                                'maxValue'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'maxValue': ['const'],
                                                                        'minValue': ['const']},
                                                     'types': {'maxValue': 'int',
                                                               'minValue': 'int'}}],
                               'setProgressStatus': [{'argInfo': {'progressString': {'doc': 'New status string',
                                                                                     'type': 'MString'}},
                                                      'args': [('progressString',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the progress status string. For example, you could use this to display the percentage of the computation which has been completed.',
                                                      'inArgs': ['progressString'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'progressString': ['const',
                                                                                            '&']},
                                                      'types': {'progressString': 'MString'}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'progress': 'getProgress'}},
  'MConditionMessage': {'enums': {},
                        'methods': {'addConditionCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                         'type': 'void'},
                                                                          'conditionName': {'doc': 'the condition to register the callback for ',
                                                                                            'type': 'MString'},
                                                                          'func': {'doc': 'the callback function',
                                                                                   'type': ('MMessage',
                                                                                            'MStateFunction')}},
                                                              'args': [('conditionName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('func',
                                                                        ('MMessage',
                                                                         'MStateFunction'),
                                                                        'in'),
                                                                       ('clientData',
                                                                        'void',
                                                                        'in')],
                                                              'defaults': {'clientData': None},
                                                              'deprecated': False,
                                                              'doc': '\r\nThis method registers a callback for condition changed messages.',
                                                              'inArgs': ['conditionName',
                                                                         'func',
                                                                         'clientData'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                             'qualifiers': [],
                                                                             'type': 'MCallbackId'},
                                                              'returnType': 'MCallbackId',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'clientData': ['*'],
                                                                                 'conditionName': ['const',
                                                                                                   '&'],
                                                                                 'func': []},
                                                              'types': {'clientData': 'void',
                                                                        'conditionName': 'MString',
                                                                        'func': ('MMessage',
                                                                                 'MStateFunction')}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'getConditionNames': [{'argInfo': {'names': {'doc': 'set to the array of available condition names.',
                                                                                 'type': 'MStringArray'}},
                                                           'args': [('names',
                                                                     'MStringArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method returns the list of available condition names.',
                                                           'inArgs': [],
                                                           'outArgs': ['names'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': True,
                                                           'typeQualifiers': {'names': ['&']},
                                                           'types': {'names': 'MStringArray'}}],
                                    'getConditionState': [{'argInfo': {'name': {'doc': 'the name of the condition. ',
                                                                                'type': 'MString'}},
                                                           'args': [('name',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method returns the current state of a condition.',
                                                           'inArgs': ['name'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The current state of the condition.',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'name': ['const',
                                                                                       '&']},
                                                           'types': {'name': 'MString'}}]},
                        'pymelEnums': {}},
  'MConnectDisconnectAttrEdit': {'enums': {},
                                 'methods': {'className': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturns the name of this class.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': ['*'],
                                                                           'type': 'char'},
                                                            'returnType': 'char',
                                                            'static': True,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                             'dstPlug': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the destination plug that was connected or disconnected for this edit. The plug can only be returned when the related reference or assembly is loaded. When the reference or assembly is unloaded, only the plug name string can be queried.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The destination plug for this edit',
                                                                         'qualifiers': [],
                                                                         'type': 'MPlug'},
                                                          'returnType': 'MPlug',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                             'dstPlugName': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nReturns the name of the destination plug that was connected or disconnected.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The name of the destination plug',
                                                                             'qualifiers': [],
                                                                             'type': 'MString'},
                                                              'returnType': 'MString',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                             'editType': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nVirtual method used to return the edit type of this edit, which is  MEdit::kConnectDisconnectEdit .',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'MEdit::kConnectDisconnectEdit',
                                                                          'qualifiers': [],
                                                                          'type': ('MEdit',
                                                                                   'EditType')},
                                                           'returnType': ('MEdit',
                                                                          'EditType'),
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                             'isConnection': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nReturns true if this edit is for a connection, false for a disconnection.',
                                                               'inArgs': [],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': 'bool'},
                                                               'returnType': 'bool',
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               'types': {}}],
                                             'srcPlug': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the source plug that was connected or disconnected for this edit. The plug can only be returned when the related reference or assembly is loaded. When the reference or assembly is unloaded, only the plug name string can be queried.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The source plug for this edit',
                                                                         'qualifiers': [],
                                                                         'type': 'MPlug'},
                                                          'returnType': 'MPlug',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                             'srcPlugName': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nReturns the name of the source plug that was connected or disconnected.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The name of the source plug',
                                                                             'qualifiers': [],
                                                                             'type': 'MString'},
                                                              'returnType': 'MString',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}]},
                                 'pymelEnums': {}},
  'MContainerMessage': {'enums': {},
                        'methods': {'addBoundAttrCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                         'type': 'void'},
                                                                          'func': {'doc': 'the callback function  node The container node  publishedName Name of the bound attr  clientData User defined data passed to the callback function   ',
                                                                                   'type': ('MMessage',
                                                                                            'MNodeStringBoolFunction')}},
                                                              'args': [('func',
                                                                        ('MMessage',
                                                                         'MNodeStringBoolFunction'),
                                                                        'in'),
                                                                       ('clientData',
                                                                        'void',
                                                                        'in')],
                                                              'defaults': {'clientData': None},
                                                              'deprecated': False,
                                                              'doc': '\nThis method registers a callback that is called whenever an attribute is bound or unbound on a container.',
                                                              'inArgs': ['func',
                                                                         'clientData'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                             'qualifiers': [],
                                                                             'type': 'MCallbackId'},
                                                              'returnType': 'MCallbackId',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'clientData': ['*'],
                                                                                 'func': []},
                                                              'types': {'clientData': 'void',
                                                                        'func': ('MMessage',
                                                                                 'MNodeStringBoolFunction')}}],
                                    'addPublishAttrCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                           'type': 'void'},
                                                                            'func': {'doc': 'the callback function  node The container node  publishedName Name of the published attr  clientData User defined data passed to the callback function   ',
                                                                                     'type': ('MMessage',
                                                                                              'MNodeStringBoolFunction')}},
                                                                'args': [('func',
                                                                          ('MMessage',
                                                                           'MNodeStringBoolFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': '\nThis method registers a callback that is called whenever an attribute is published or unpublished from a container.',
                                                                'inArgs': ['func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'func': []},
                                                                'types': {'clientData': 'void',
                                                                          'func': ('MMessage',
                                                                                   'MNodeStringBoolFunction')}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                        'pymelEnums': {}},
  'MCursor': {'enums': {},
              'methods': {'__eq__': [{'argInfo': {'other': {'doc': 'the MCursor object to be compared with.',
                                                            'type': 'MCursor'}},
                                      'args': [('other',
                                                'MCursor',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nEquality operator. Allows 2 MCursors to be compared to see if they are identical.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' true if the objects are same.  false if the objects are different.   ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MCursor'}}],
                          '__ne__': [{'argInfo': {'other': {'doc': 'the MCursor object to be compared with.',
                                                            'type': 'MCursor'}},
                                      'args': [('other',
                                                'MCursor',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nInequality operator. Allows 2 MCursors to be compared to see if they are not the same.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' true if the objects are different.  false if the objects are same.   ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MCursor'}}]},
              'pymelEnums': {}},
  'MCurveAttribute': {'enums': {},
                      'methods': {'addEntries': [{'argInfo': {'positions': {'doc': 'the positions of the new entries (can range from 0 to 1) ',
                                                                            'type': 'MFloatArray'},
                                                              'values': {'doc': 'the values of the new entry at each position ',
                                                                         'type': 'MFloatArray'}},
                                                  'args': [('positions',
                                                            'MFloatArray',
                                                            'in'),
                                                           ('values',
                                                            'MFloatArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAdds entries into a curve attribute.',
                                                  'inArgs': ['positions',
                                                             'values'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'positions': ['&'],
                                                                     'values': ['&']},
                                                  'types': {'positions': 'MFloatArray',
                                                            'values': 'MFloatArray'}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'createCurve': [{'argInfo': {'attrLongName': {'doc': 'Long name of the new curve attribute ',
                                                                                'type': 'MString'},
                                                               'attrShortName': {'doc': 'Short name of the new curve attribute ',
                                                                                 'type': 'MString'},
                                                               'node': {'doc': 'The node to which the new attribute will be added ',
                                                                        'type': 'MObject'},
                                                               'positions': {'doc': 'Array of desired positions. ',
                                                                             'type': 'MFloatArray'},
                                                               'values': {'doc': 'Array of float value. ',
                                                                          'type': 'MFloatArray'}},
                                                   'args': [('attrLongName',
                                                             'MString',
                                                             'in'),
                                                            ('attrShortName',
                                                             'MString',
                                                             'in'),
                                                            ('node',
                                                             'MObject',
                                                             'in'),
                                                            ('values',
                                                             'MFloatArray',
                                                             'in'),
                                                            ('positions',
                                                             'MFloatArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nCreates a new curve attribute initialized with entries defined from a set of float, position value arrays.',
                                                   'inArgs': ['attrLongName',
                                                              'attrShortName',
                                                              'node',
                                                              'values',
                                                              'positions'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'attrLongName': ['const',
                                                                                       '&'],
                                                                      'attrShortName': ['const',
                                                                                        '&'],
                                                                      'node': ['const',
                                                                               '&'],
                                                                      'positions': ['const',
                                                                                    '&'],
                                                                      'values': ['const',
                                                                                 '&']},
                                                   'types': {'attrLongName': 'MString',
                                                             'attrShortName': 'MString',
                                                             'node': 'MObject',
                                                             'positions': 'MFloatArray',
                                                             'values': 'MFloatArray'}}],
                                  'createCurveAttr': [{'argInfo': {'attrLongName': {'doc': 'Long name of the curve attribute ',
                                                                                    'type': 'MString'},
                                                                   'attrShortName': {'doc': 'Short name of the curve attribute ',
                                                                                     'type': 'MString'}},
                                                       'args': [('attrLongName',
                                                                 'MString',
                                                                 'in'),
                                                                ('attrShortName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis function creates the curve attribute.',
                                                       'inArgs': ['attrLongName',
                                                                  'attrShortName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Curve ramp attribute, returned as MObject.',
                                                                      'qualifiers': [],
                                                                      'type': 'MObject'},
                                                       'returnType': 'MObject',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'attrLongName': ['const',
                                                                                           '&'],
                                                                          'attrShortName': ['const',
                                                                                            '&']},
                                                       'types': {'attrLongName': 'MString',
                                                                 'attrShortName': 'MString'}}],
                                  'deleteEntries': [{'argInfo': {'indices': {'doc': 'the entries that need to be deleted ',
                                                                             'type': 'MIntArray'}},
                                                     'args': [('indices',
                                                               'MIntArray',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nDeletes entries in the curve attribute.',
                                                     'inArgs': ['indices'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'indices': ['&']},
                                                     'types': {'indices': 'MIntArray'}}],
                                  'getEntries': [{'argInfo': {'indices': {'doc': 'unique values that specify each entry in the curve ',
                                                                          'type': 'MIntArray'},
                                                              'positions': {'doc': 'the positions of each entry (can range from 0 to 1) ',
                                                                            'type': 'MFloatArray'},
                                                              'values': {'doc': 'the values of the entries at each position (can range from 0 to 1) ',
                                                                         'type': 'MFloatArray'}},
                                                  'args': [('indices',
                                                            'MIntArray',
                                                            'out'),
                                                           ('positions',
                                                            'MFloatArray',
                                                            'out'),
                                                           ('values',
                                                            'MFloatArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGets all the entries in a curve attribute.',
                                                  'inArgs': [],
                                                  'outArgs': ['indices',
                                                              'positions',
                                                              'values'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'indices': ['&'],
                                                                     'positions': ['&'],
                                                                     'values': ['&']},
                                                  'types': {'indices': 'MIntArray',
                                                            'positions': 'MFloatArray',
                                                            'values': 'MFloatArray'}}],
                                  'getNumEntries': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the number of entries in the curve attribute.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The number of entries in the curve attribute ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                  'getValueAtPosition': [{'argInfo': {'position': {'doc': 'the desired position (x-axis) ',
                                                                                   'type': 'float'},
                                                                      'value': {'doc': 'the y-axis value at the position ',
                                                                                'type': 'float'}},
                                                          'args': [('position',
                                                                    'float',
                                                                    'in'),
                                                                   ('value',
                                                                    'float',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGets the value (y-axis) at the given position (x-axis) x If this curve is empty, then this method will return a failure. If the position is out of range, either the start or end value will be returned.',
                                                          'inArgs': ['position'],
                                                          'outArgs': ['value'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'position': [],
                                                                             'value': ['&']},
                                                          'types': {'position': 'float',
                                                                    'value': 'float'}}],
                                  'getValuesAtPositions': [{'argInfo': {'positions': {'doc': 'the desired x-axis positions ',
                                                                                      'type': 'MFloatArray'},
                                                                        'values': {'doc': 'the y-axis values at the positions ',
                                                                                   'type': 'MFloatArray'}},
                                                            'args': [('positions',
                                                                      'MFloatArray',
                                                                      'out'),
                                                                     ('values',
                                                                      'MFloatArray',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nGets the values (y-axis) at the given positions (x-axis)',
                                                            'inArgs': [],
                                                            'outArgs': ['positions',
                                                                        'values'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'positions': ['const',
                                                                                             '&'],
                                                                               'values': ['&']},
                                                            'types': {'positions': 'MFloatArray',
                                                                      'values': 'MFloatArray'}}],
                                  'hasIndex': [{'argInfo': {'index': {'doc': 'Index to query. ',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns true if this curve attribute has an entry defined with a given index.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'True if the index exists, false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                                  'pack': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nChange the indices numbering by re-ordering them from 0.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                  'sampleValueCurve': [{'argInfo': {'numberOfSamples': {'doc': 'The number of times to sample the ramp ',
                                                                                        'type': 'uint'},
                                                                    'values': {'doc': 'The returned ramp samples ',
                                                                               'type': 'MFloatArray'}},
                                                        'args': [('numberOfSamples',
                                                                  'uint',
                                                                  'in'),
                                                                 ('values',
                                                                  'MFloatArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nPerform a linear sampling of this curve ramp and return the results.',
                                                        'inArgs': ['numberOfSamples'],
                                                        'outArgs': ['values'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'numberOfSamples': ['unsigned'],
                                                                           'values': ['&']},
                                                        'types': {'numberOfSamples': 'uint',
                                                                  'values': 'MFloatArray'}}],
                                  'setCurve': [{'argInfo': {'positions': {'doc': 'Array of desired positions.',
                                                                          'type': 'MFloatArray'},
                                                            'values': {'doc': 'Array of float value. ',
                                                                       'type': 'MFloatArray'}},
                                                'args': [('values',
                                                          'MFloatArray',
                                                          'in'),
                                                         ('positions',
                                                          'MFloatArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets this curve attribute with entries defined from a set of float, position value arrays. Existing entries are deleted before the new ones are added.',
                                                'inArgs': ['values',
                                                           'positions'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'positions': ['const',
                                                                                 '&'],
                                                                   'values': ['const',
                                                                              '&']},
                                                'types': {'positions': 'MFloatArray',
                                                          'values': 'MFloatArray'}}],
                                  'setPositionAtIndex': [{'argInfo': {'index': {'doc': 'index of entry to change ',
                                                                                'type': 'uint'},
                                                                      'position': {'doc': 'the new position for the entry ',
                                                                                   'type': 'float'}},
                                                          'args': [('position',
                                                                    'float',
                                                                    'in'),
                                                                   ('index',
                                                                    'uint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSets the position of a given entry',
                                                          'inArgs': ['position',
                                                                     'index'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'index': ['unsigned'],
                                                                             'position': []},
                                                          'types': {'index': 'uint',
                                                                    'position': 'float'}}],
                                  'setValueAtIndex': [{'argInfo': {'index': {'doc': 'index of entry to change ',
                                                                             'type': 'uint'},
                                                                   'value': {'doc': 'the new value for the entry ',
                                                                             'type': 'float'}},
                                                       'args': [('value',
                                                                 'float',
                                                                 'in'),
                                                                ('index',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the value of a given entry',
                                                       'inArgs': ['value',
                                                                  'index'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'index': ['unsigned'],
                                                                          'value': []},
                                                       'types': {'index': 'uint',
                                                                 'value': 'float'}}],
                                  'sort': [{'argInfo': {'ascending': {'doc': 'Option for sorting in ascending (default) or descending order.',
                                                                      'type': 'bool'}},
                                            'args': [('ascending',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'ascending': True},
                                            'deprecated': False,
                                            'doc': '\r\nSort the curve attribute entries by position in ascending or descending order, other arrays are sorted accordingly. Indices are also compressed during the operation.',
                                            'inArgs': ['ascending'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'ascending': []},
                                            'types': {'ascending': 'bool'}}]},
                      'pymelEnums': {}},
  'MD3D9Renderer': {'enums': {},
                    'methods': {'makeSwatchContextCurrent': [{'argInfo': {'height': {'doc': 'The height of the swatch image.',
                                                                                     'type': 'uint'},
                                                                          'width': {'doc': 'The width of the swatch image. ',
                                                                                    'type': 'uint'}},
                                                              'args': [('width',
                                                                        'uint',
                                                                        'out'),
                                                                       ('height',
                                                                        'uint',
                                                                        'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nCreate a directX render target (or context) to render into for swatches.',
                                                              'inArgs': [],
                                                              'outArgs': ['width',
                                                                          'height'],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'height': ['unsigned',
                                                                                            '&'],
                                                                                 'width': ['unsigned',
                                                                                           '&']},
                                                              'types': {'height': 'uint',
                                                                        'width': 'uint'}}],
                                'readSwatchContextPixels': [{'argInfo': {'image': {'doc': 'The image to copy the swatch into',
                                                                                   'type': 'MImage'}},
                                                             'args': [('image',
                                                                       'MImage',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReads out the current swatch context color buffer into an image format.',
                                                             'inArgs': ['image'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'image': ['&']},
                                                             'types': {'image': 'MImage'}}],
                                'setBackgroundColor': [{'argInfo': {'color': {'doc': 'The color to which the backgorund color will be set.',
                                                                              'type': 'MColor'}},
                                                        'args': [('color',
                                                                  'MColor',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSet the back ground color of the swatch. This clear the reading buffer as well.',
                                                        'inArgs': ['color'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'color': ['const',
                                                                                     '&']},
                                                        'types': {'color': 'MColor'}}],
                                'theRenderer': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns a static pointer to the hardware renderer wrapper class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Pointer to a MD3D9Renderer. ',
                                                                'qualifiers': ['*'],
                                                                'type': 'MD3D9Renderer'},
                                                 'returnType': 'MD3D9Renderer',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                    'pymelEnums': {}},
  'MDAGDrawOverrideInfo': {'enums': {'DrawOverrideDisplayType': {'valueDocs': {'kDisplayTypeNormal': 'Display as normal.',
                                                                               'kDisplayTypeReference': 'Display as reference.',
                                                                               'kDisplayTypeTemplate': 'Display as templated(not selectable, only show as wireframe).',
                                                                               'normal': 'Display as normal.',
                                                                               'reference': 'Display as reference.',
                                                                               'template': 'Display as templated(not selectable, only show as wireframe).'},
                                                                 'values': "Enum('DrawOverrideDisplayType', {'kDisplayTypeNormal': 0, 'kDisplayTypeReference': 1, 'kDisplayTypeTemplate': 2})"},
                                     'DrawOverrideLOD': {'valueDocs': {'boundingBox': 'Display only a bounding box, nothing else.',
                                                                       'full': 'Display all render items like shaded, wireframe as full detailed.',
                                                                       'kLODBoundingBox': 'Display only a bounding box, nothing else.',
                                                                       'kLODFull': 'Display all render items like shaded, wireframe as full detailed.'},
                                                         'values': "Enum('DrawOverrideLOD', {'kLODFull': 0, 'kLODBoundingBox': 1})"}},
                           'methods': {},
                           'pymelEnums': {'DrawOverrideDisplayType': "Enum('DrawOverrideDisplayType', [('normal', 0), ('kDisplayTypeNormal', 0), ('reference', 1), ('kDisplayTypeReference', 1), ('template', 2), ('kDisplayTypeTemplate', 2)], multiKeys=True)",
                                          'DrawOverrideLOD': "Enum('DrawOverrideLOD', [('full', 0), ('kLODFull', 0), ('boundingBox', 1), ('kLODBoundingBox', 1)], multiKeys=True)"}},
  'MDGContext': {'enums': {},
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'current': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nExtract the current context being used for evaluation.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Current evaluation context ',
                                                         'qualifiers': [],
                                                         'type': 'MDGContext'},
                                          'returnType': 'MDGContext',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                             'getTime': [{'argInfo': {'timeVal': {'doc': 'Storage for the time',
                                                                  'type': 'MTime'}},
                                          'args': [('timeVal',
                                                    'MTime',
                                                    'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturn the single time for which this context is valid. The context must be a timed context, i.e. not a normal one.',
                                          'inArgs': [],
                                          'outArgs': ['timeVal'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'timeVal': ['&']},
                                          'types': {'timeVal': 'MTime'}}],
                             'isCurrent': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermines if this context is the one currently being used for evaluation.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true this context is currently being used for evaluation  false this context is not currently being used for evaluation  ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                             'isNormal': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nDetermines if this context is that of "normal" evaluation.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': ' true this context is normal  false this context is not normal  ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                             'makeCurrent': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the context to be the current evaluation context.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Previous current evaluation context',
                                                             'qualifiers': [],
                                                             'type': 'MDGContext'},
                                              'returnType': 'MDGContext',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}]},
                 'pymelEnums': {}},
  'MDGContextGuard': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDGMessage': {'enums': {},
                 'methods': {'addConnectionCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                   'type': 'void'},
                                                                    'func': {'doc': 'the callback function  srcPlug Source plug of the connection  destPlug Destination plug of the connection  made true if a new connection was made, false if broken.  clientData User defined data passed to the callback function   ',
                                                                             'type': ('MMessage',
                                                                                      'MPlugFunction')}},
                                                        'args': [('func',
                                                                  ('MMessage',
                                                                   'MPlugFunction'),
                                                                  'in'),
                                                                 ('clientData',
                                                                  'void',
                                                                  'in')],
                                                        'defaults': {'clientData': None},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method registers a callback that is called whenever a connection is made or broken in the dependency graph. This callback is triggered after the given connection has been made or broken, unlike the addPreConnectionCallback which is triggered before the operation.',
                                                        'inArgs': ['func',
                                                                   'clientData'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                       'qualifiers': [],
                                                                       'type': 'MCallbackId'},
                                                        'returnType': 'MCallbackId',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'clientData': ['*'],
                                                                           'func': []},
                                                        'types': {'clientData': 'void',
                                                                  'func': ('MMessage',
                                                                           'MPlugFunction')}}],
                             'addDelayedTimeChangeCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                          'type': 'void'},
                                                                           'func': {'doc': 'the callback function  time the new time  clientData User defined data passed to the callback function   ',
                                                                                    'type': ('MMessage',
                                                                                             'MTimeFunction')}},
                                                               'args': [('func',
                                                                         ('MMessage',
                                                                          'MTimeFunction'),
                                                                         'in'),
                                                                        ('clientData',
                                                                         'void',
                                                                         'in')],
                                                               'defaults': {'clientData': None},
                                                               'deprecated': False,
                                                               'doc': '\r\nThis method registers a callback that is called whenever the time changes in the dependency graph, but after the time changed callback',
                                                               'inArgs': ['func',
                                                                          'clientData'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                              'qualifiers': [],
                                                                              'type': 'MCallbackId'},
                                                               'returnType': 'MCallbackId',
                                                               'static': True,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'clientData': ['*'],
                                                                                  'func': []},
                                                               'types': {'clientData': 'void',
                                                                         'func': ('MMessage',
                                                                                  'MTimeFunction')}}],
                             'addDelayedTimeChangeRunupCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                               'type': 'void'},
                                                                                'func': {'doc': 'the callback function  time the new time  clientData User defined data passed to the callback function   ',
                                                                                         'type': ('MMessage',
                                                                                                  'MTimeFunction')}},
                                                                    'args': [('func',
                                                                              ('MMessage',
                                                                               'MTimeFunction'),
                                                                              'in'),
                                                                             ('clientData',
                                                                              'void',
                                                                              'in')],
                                                                    'defaults': {'clientData': None},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nThis method registers a callback that is called whenever the time changes in the dependency graph, but after the other time changed callbacks which can be used to invoke a dynamics solve or runup if needed',
                                                                    'inArgs': ['func',
                                                                               'clientData'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                   'qualifiers': [],
                                                                                   'type': 'MCallbackId'},
                                                                    'returnType': 'MCallbackId',
                                                                    'static': True,
                                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                       'clientData': ['*'],
                                                                                       'func': []},
                                                                    'types': {'clientData': 'void',
                                                                              'func': ('MMessage',
                                                                                       'MTimeFunction')}}],
                             'addForceUpdateCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                    'type': 'void'},
                                                                     'func': {'doc': 'the callback function  time the new time  clientData User defined data passed to the callback function   ',
                                                                              'type': ('MMessage',
                                                                                       'MTimeFunction')}},
                                                         'args': [('func',
                                                                   ('MMessage',
                                                                    'MTimeFunction'),
                                                                   'in'),
                                                                  ('clientData',
                                                                   'void',
                                                                   'in')],
                                                         'defaults': {'clientData': None},
                                                         'deprecated': False,
                                                         'doc': '\r\nThis method registers a callback that is called after the time changes and after all nodes have been evaluated in the dependency graph.',
                                                         'inArgs': ['func',
                                                                    'clientData'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                        'qualifiers': [],
                                                                        'type': 'MCallbackId'},
                                                         'returnType': 'MCallbackId',
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'clientData': ['*'],
                                                                            'func': []},
                                                         'types': {'clientData': 'void',
                                                                   'func': ('MMessage',
                                                                            'MTimeFunction')}}],
                             'addNodeAddedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                  'type': 'void'},
                                                                   'func': {'doc': 'the callback function  node the new node  clientData User defined data passed to the callback function   ',
                                                                            'type': ('MMessage',
                                                                                     'MNodeFunction')},
                                                                   'nodeType': {'doc': 'Type of node that will trigger the callback ',
                                                                                'type': 'MString'}},
                                                       'args': [('func',
                                                                 ('MMessage',
                                                                  'MNodeFunction'),
                                                                 'in'),
                                                                ('nodeType',
                                                                 'MString',
                                                                 'in'),
                                                                ('clientData',
                                                                 'void',
                                                                 'in')],
                                                       'defaults': {'clientData': None,
                                                                    'nodeType': '"dependNode"'},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method registers a callback that is called whenever a new node is added to the dependency graph. The nodeType argument allows you to specify the type of nodes that will trigger the callback. The default node type is "dependNode" which matches all nodes.',
                                                       'inArgs': ['func',
                                                                  'nodeType',
                                                                  'clientData'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                      'qualifiers': [],
                                                                      'type': 'MCallbackId'},
                                                       'returnType': 'MCallbackId',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'clientData': ['*'],
                                                                          'func': [],
                                                                          'nodeType': ['const',
                                                                                       '&']},
                                                       'types': {'clientData': 'void',
                                                                 'func': ('MMessage',
                                                                          'MNodeFunction'),
                                                                 'nodeType': 'MString'}}],
                             'addNodeChangeUuidCheckCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                            'type': 'void'},
                                                                             'func': {'doc': 'the callback function  doAction Whether the UUID will be applied  node The node whose UUID may be changed  uuid The UUID that may be applied to the node (typically the one read from the file, during file I/O) The callback may provide its own uuid to be applied by changing this parameter.  clientData User defined data passed to the callback function   ',
                                                                                      'type': ('MMessage',
                                                                                               'MCheckNodeUuidFunction')}},
                                                                 'args': [('func',
                                                                           ('MMessage',
                                                                            'MCheckNodeUuidFunction'),
                                                                           'in'),
                                                                          ('clientData',
                                                                           'void',
                                                                           'in')],
                                                                 'defaults': {'clientData': None},
                                                                 'deprecated': False,
                                                                 'doc': "\r\nThis method registers a callback that is called whenever a node may have its UUID changed. Possible causes include the 'rename' command, and the UUID for a node being read from a file during file I/O.",
                                                                 'inArgs': ['func',
                                                                            'clientData'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                'qualifiers': [],
                                                                                'type': 'MCallbackId'},
                                                                 'returnType': 'MCallbackId',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'clientData': ['*'],
                                                                                    'func': []},
                                                                 'types': {'clientData': 'void',
                                                                           'func': ('MMessage',
                                                                                    'MCheckNodeUuidFunction')}}],
                             'addNodeRemovedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                    'type': 'void'},
                                                                     'func': {'doc': 'the callback function  node the node being removed  clientData User defined data passed to the callback function   ',
                                                                              'type': ('MMessage',
                                                                                       'MNodeFunction')},
                                                                     'nodeType': {'doc': 'Type of node that will trigger the callback ',
                                                                                  'type': 'MString'}},
                                                         'args': [('func',
                                                                   ('MMessage',
                                                                    'MNodeFunction'),
                                                                   'in'),
                                                                  ('nodeType',
                                                                   'MString',
                                                                   'in'),
                                                                  ('clientData',
                                                                   'void',
                                                                   'in')],
                                                         'defaults': {'clientData': None,
                                                                      'nodeType': '"dependNode"'},
                                                         'deprecated': False,
                                                         'doc': '\r\nThis method registers a callback that is called whenever a new node is removed from the dependency graph. The nodeType argument allows you to specify the type of nodes that will trigger the callback. The default node type is "dependNode" which matches all nodes.',
                                                         'inArgs': ['func',
                                                                    'nodeType',
                                                                    'clientData'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                        'qualifiers': [],
                                                                        'type': 'MCallbackId'},
                                                         'returnType': 'MCallbackId',
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'clientData': ['*'],
                                                                            'func': [],
                                                                            'nodeType': ['const',
                                                                                         '&']},
                                                         'types': {'clientData': 'void',
                                                                   'func': ('MMessage',
                                                                            'MNodeFunction'),
                                                                   'nodeType': 'MString'}}],
                             'addPreConnectionCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                      'type': 'void'},
                                                                       'func': {'doc': 'the callback function  srcPlug Source plug of the connection  destPlug Destination plug of the connection  made true if a new connection will be made, false if it will be broken.  clientData User defined data passed to the callback function   ',
                                                                                'type': ('MMessage',
                                                                                         'MPlugFunction')}},
                                                           'args': [('func',
                                                                     ('MMessage',
                                                                      'MPlugFunction'),
                                                                     'in'),
                                                                    ('clientData',
                                                                     'void',
                                                                     'in')],
                                                           'defaults': {'clientData': None},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method registers a callback that is called whenever any connection is made or broken in the dependency graph. This callback is triggered before the given connection has been made or broken, unlike the addConnectionCallback which is triggered after the operation.',
                                                           'inArgs': ['func',
                                                                      'clientData'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                          'qualifiers': [],
                                                                          'type': 'MCallbackId'},
                                                           'returnType': 'MCallbackId',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'clientData': ['*'],
                                                                              'func': []},
                                                           'types': {'clientData': 'void',
                                                                     'func': ('MMessage',
                                                                              'MPlugFunction')}}],
                             'addTimeChangeCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                   'type': 'void'},
                                                                    'func': {'doc': 'the callback function  time the new time  clientData User defined data passed to the callback function   ',
                                                                             'type': ('MMessage',
                                                                                      'MTimeFunction')}},
                                                        'args': [('func',
                                                                  ('MMessage',
                                                                   'MTimeFunction'),
                                                                  'in'),
                                                                 ('clientData',
                                                                  'void',
                                                                  'in')],
                                                        'defaults': {'clientData': None},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method registers a callback that is called whenever the time changes in the dependency graph.',
                                                        'inArgs': ['func',
                                                                   'clientData'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                       'qualifiers': [],
                                                                       'type': 'MCallbackId'},
                                                        'returnType': 'MCallbackId',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'clientData': ['*'],
                                                                           'func': []},
                                                        'types': {'clientData': 'void',
                                                                  'func': ('MMessage',
                                                                           'MTimeFunction')}}]},
                 'pymelEnums': {}},
  'MDGModifier': {'enums': {},
                  'methods': {'addAttribute': [{'argInfo': {'attribute': {'doc': 'attribute to add',
                                                                          'type': 'MObject'},
                                                            'node': {'doc': 'node to which to add the attribute ',
                                                                     'type': 'MObject'}},
                                                'args': [('node',
                                                          'MObject',
                                                          'in'),
                                                         ('attribute',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nAdd a new dynamic attribute to the given dependency node.',
                                                'inArgs': ['node',
                                                           'attribute'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attribute': ['const',
                                                                                 '&'],
                                                                   'node': ['const',
                                                                            '&']},
                                                'types': {'attribute': 'MObject',
                                                          'node': 'MObject'}},
                                               {'argInfo': {'attribute': {'doc': 'attribute to add ',
                                                                          'type': 'MObject'},
                                                            'node': {'doc': 'node to add an attribute to ',
                                                                     'type': 'MObject'},
                                                            'type': {'doc': 'determines if this is a local or global attribute',
                                                                     'type': ('MFnDependencyNode',
                                                                              'MAttrClass')}},
                                                'args': [('node',
                                                          'MObject',
                                                          'in'),
                                                         ('attribute',
                                                          'MObject',
                                                          'in'),
                                                         ('type',
                                                          ('MFnDependencyNode',
                                                           'MAttrClass'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': True,
                                                'doc': '\n Deprecated: Use the method  MDGModifier::addAttribute( const MObject&, const MObject& )  instead \r\nThis method also adds all children of the attribute if it is a compound. So, if a compound attribute is being added to a node, then only the parent attribute needs to be added using this method.',
                                                'inArgs': ['node',
                                                           'attribute',
                                                           'type'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attribute': ['const',
                                                                                 '&'],
                                                                   'node': ['const',
                                                                            '&'],
                                                                   'type': []},
                                                'types': {'attribute': 'MObject',
                                                          'node': 'MObject',
                                                          'type': ('MFnDependencyNode',
                                                                   'MAttrClass')}}],
                              'addExtensionAttribute': [{'argInfo': {'attribute': {'doc': 'attribute to add',
                                                                                   'type': 'MObject'},
                                                                     'nodeClass': {'doc': 'class of node to which to add the attribute ',
                                                                                   'type': 'MNodeClass'}},
                                                         'args': [('nodeClass',
                                                                   'MNodeClass',
                                                                   'in'),
                                                                  ('attribute',
                                                                   'MObject',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nAdd a new extension attribute to the given dependency node class.',
                                                         'inArgs': ['nodeClass',
                                                                    'attribute'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'attribute': ['const',
                                                                                          '&'],
                                                                            'nodeClass': ['const',
                                                                                          '&']},
                                                         'types': {'attribute': 'MObject',
                                                                   'nodeClass': 'MNodeClass'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'commandToExecute': [{'argInfo': {'command': {'doc': 'the command that will be executed (should be undoable)',
                                                                            'type': 'MString'}},
                                                    'args': [('command',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nAdds an operation to this dependency graph modifier that executes a MEL command.',
                                                    'inArgs': ['command'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'command': ['const',
                                                                                   '&']},
                                                    'types': {'command': 'MString'}}],
                              'connect': [{'argInfo': {'destAttr': {'doc': 'the attribute of the destination node that is to be connected',
                                                                    'type': 'MObject'},
                                                       'destNode': {'doc': 'the destination node in the connection ',
                                                                    'type': 'MObject'},
                                                       'sourceAttr': {'doc': 'the attribute of the source node that is to be connected ',
                                                                      'type': 'MObject'},
                                                       'sourceNode': {'doc': 'the source node in the connection ',
                                                                      'type': 'MObject'}},
                                           'args': [('sourceNode',
                                                     'MObject',
                                                     'in'),
                                                    ('sourceAttr',
                                                     'MObject',
                                                     'in'),
                                                    ('destNode',
                                                     'MObject',
                                                     'in'),
                                                    ('destAttr',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nAdds an operation to this dependency graph modifier that connects two attributes of two nodes in the dependency graph. The value of the destination attribute is supplied by the value of the source attribute once they are connected.',
                                           'inArgs': ['sourceNode',
                                                      'sourceAttr',
                                                      'destNode',
                                                      'destAttr'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'destAttr': ['const',
                                                                           '&'],
                                                              'destNode': ['const',
                                                                           '&'],
                                                              'sourceAttr': ['const',
                                                                             '&'],
                                                              'sourceNode': ['const',
                                                                             '&']},
                                           'types': {'destAttr': 'MObject',
                                                     'destNode': 'MObject',
                                                     'sourceAttr': 'MObject',
                                                     'sourceNode': 'MObject'}},
                                          {'argInfo': {'dest': {'doc': 'the destination plug in the connection',
                                                                'type': 'MPlug'},
                                                       'source': {'doc': 'the source plug in the connection ',
                                                                  'type': 'MPlug'}},
                                           'args': [('source',
                                                     'MPlug',
                                                     'in'),
                                                    ('dest',
                                                     'MPlug',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nAdds an operation to this dependency graph modifier that connects two plugs in the dependency graph. The value of the destination plug is supplied by the value of the source plug once they are connected.',
                                           'inArgs': ['source', 'dest'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'dest': ['const',
                                                                       '&'],
                                                              'source': ['const',
                                                                         '&']},
                                           'types': {'dest': 'MPlug',
                                                     'source': 'MPlug'}}],
                              'createNode': [{'argInfo': {'typeId': {'doc': 'type of the node to create ',
                                                                     'type': 'MTypeId'}},
                                              'args': [('typeId',
                                                        'MTypeId',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method adds an operation to this dependency graph modifier that will add a new dependency graph node of the given type to the dependency graph. This method may not be used to construct new DAG nodes. Use  MDagModifier  for that purpose.',
                                              'inArgs': ['typeId'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A handle for the new node',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'typeId': ['const',
                                                                            '&']},
                                              'types': {'typeId': 'MTypeId'}},
                                             {'argInfo': {'type': {'doc': 'type name of the node to create ',
                                                                   'type': 'MString'}},
                                              'args': [('type',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method adds an operation to this dependency graph modifier that will add a new dependency graph node of the given type to the dependency graph. This method may not be used to construct new DAG nodes. Use  MDagModifier  for that purpose.',
                                              'inArgs': ['type'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A handle for the new node',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'type': ['const',
                                                                          '&']},
                                              'types': {'type': 'MString'}}],
                              'deleteMetadata': [{'argInfo': {'node': {'doc': 'the node from which the metadata is to be removed',
                                                                       'type': 'MObject'}},
                                                  'args': [('node',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAdds an operation to this dependency graph modifier that deletes all metadata from a node.',
                                                  'inArgs': ['node'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'node': ['const',
                                                                              '&']},
                                                  'types': {'node': 'MObject'}}],
                              'deleteNode': [{'argInfo': {'node': {'doc': 'node to delete',
                                                                   'type': 'MObject'}},
                                              'args': [('node',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method adds an operation to this dependency graph modifier that will delete a dependency graph node from the dependency graph.',
                                              'inArgs': ['node'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'node': ['const',
                                                                          '&']},
                                              'types': {'node': 'MObject'}}],
                              'disconnect': [{'argInfo': {'destAttr': {'doc': 'the attribute of the destination node that is connected',
                                                                       'type': 'MObject'},
                                                          'destNode': {'doc': 'the destination node in the connection ',
                                                                       'type': 'MObject'},
                                                          'sourceAttr': {'doc': 'the attribute of the source node that is connected ',
                                                                         'type': 'MObject'},
                                                          'sourceNode': {'doc': 'the source node in the connection ',
                                                                         'type': 'MObject'}},
                                              'args': [('sourceNode',
                                                        'MObject',
                                                        'in'),
                                                       ('sourceAttr',
                                                        'MObject',
                                                        'in'),
                                                       ('destNode',
                                                        'MObject',
                                                        'in'),
                                                       ('destAttr',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nAdds an operation to this dependency graph modifier that disconnects two attributes of two nodes in the dependency graph.',
                                              'inArgs': ['sourceNode',
                                                         'sourceAttr',
                                                         'destNode',
                                                         'destAttr'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'destAttr': ['const',
                                                                              '&'],
                                                                 'destNode': ['const',
                                                                              '&'],
                                                                 'sourceAttr': ['const',
                                                                                '&'],
                                                                 'sourceNode': ['const',
                                                                                '&']},
                                              'types': {'destAttr': 'MObject',
                                                        'destNode': 'MObject',
                                                        'sourceAttr': 'MObject',
                                                        'sourceNode': 'MObject'}},
                                             {'argInfo': {'dest': {'doc': 'the destination plug in the connection',
                                                                   'type': 'MPlug'},
                                                          'source': {'doc': 'the source plug in the connection ',
                                                                     'type': 'MPlug'}},
                                              'args': [('source',
                                                        'MPlug',
                                                        'in'),
                                                       ('dest',
                                                        'MPlug',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nAdds an operation to this dependency graph modifier that disconnects two plugs in the dependency graph.',
                                              'inArgs': ['source',
                                                         'dest'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'dest': ['const',
                                                                          '&'],
                                                                 'source': ['const',
                                                                            '&']},
                                              'types': {'dest': 'MPlug',
                                                        'source': 'MPlug'}}],
                              'doIt': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nExecutes all of the operations that have been given to this modifier. It is only valid to call this method after all of the operations have been specified. This method may also be called after undoIt to redo the operations.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'linkExtensionAttributeToPlugin': [{'argInfo': {'mAttribute': {'doc': 'attribute to associate with the plugin, must not have a parent',
                                                                                             'type': 'MObject'},
                                                                              'mPlugin': {'doc': 'plugin to which the attribute is to be tied ',
                                                                                          'type': 'MObject'}},
                                                                  'args': [('mPlugin',
                                                                            'MObject',
                                                                            'in'),
                                                                           ('mAttribute',
                                                                            'MObject',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nThe plugin calls this to indicate that the extension attribute defines part of the plugin, regardless of the node type to which it attaches itself. This requirement is used when the plugin is checked to see if it is in use or if is able to be unloaded or if it is required as part of a stored file.',
                                                                  'inArgs': ['mPlugin',
                                                                             'mAttribute'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'mAttribute': ['const',
                                                                                                    '&'],
                                                                                     'mPlugin': ['const',
                                                                                                 '&']},
                                                                  'types': {'mAttribute': 'MObject',
                                                                            'mPlugin': 'MObject'}}],
                              'newPlugValue': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                     'type': 'MPlug'},
                                                            'plugValue': {'doc': 'the value to set',
                                                                          'type': 'MObject'}},
                                                'args': [('plug',
                                                          'MPlug',
                                                          'in'),
                                                         ('plugValue',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug value. Plug values can be created with the  MFnNumericData  class.',
                                                'inArgs': ['plug',
                                                           'plugValue'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'plug': ['const',
                                                                            '&'],
                                                                   'plugValue': ['&']},
                                                'types': {'plug': 'MPlug',
                                                          'plugValue': 'MObject'}}],
                              'newPlugValueBool': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                         'type': 'MPlug'},
                                                                'plugValue': {'doc': 'the value to set',
                                                                              'type': 'bool'}},
                                                    'args': [('plug',
                                                              'MPlug',
                                                              'in'),
                                                             ('plugValue',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to a boolean value.',
                                                    'inArgs': ['plug',
                                                               'plugValue'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'plug': ['const',
                                                                                '&'],
                                                                       'plugValue': []},
                                                    'types': {'plug': 'MPlug',
                                                              'plugValue': 'bool'}}],
                              'newPlugValueChar': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                         'type': 'MPlug'},
                                                                'plugValue': {'doc': 'the value to set',
                                                                              'type': 'char'}},
                                                    'args': [('plug',
                                                              'MPlug',
                                                              'in'),
                                                             ('plugValue',
                                                              'char',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to a char value.',
                                                    'inArgs': ['plug',
                                                               'plugValue'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'plug': ['const',
                                                                                '&'],
                                                                       'plugValue': []},
                                                    'types': {'plug': 'MPlug',
                                                              'plugValue': 'char'}}],
                              'newPlugValueDouble': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                           'type': 'MPlug'},
                                                                  'plugValue': {'doc': 'the value to set',
                                                                                'type': 'double'}},
                                                      'args': [('plug',
                                                                'MPlug',
                                                                'in'),
                                                               ('plugValue',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to a double value.',
                                                      'inArgs': ['plug',
                                                                 'plugValue'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'plug': ['const',
                                                                                  '&'],
                                                                         'plugValue': []},
                                                      'types': {'plug': 'MPlug',
                                                                'plugValue': 'double'}}],
                              'newPlugValueFloat': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                          'type': 'MPlug'},
                                                                 'plugValue': {'doc': 'the value to set',
                                                                               'type': 'float'}},
                                                     'args': [('plug',
                                                               'MPlug',
                                                               'in'),
                                                              ('plugValue',
                                                               'float',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to a float value.',
                                                     'inArgs': ['plug',
                                                                'plugValue'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'plug': ['const',
                                                                                 '&'],
                                                                        'plugValue': []},
                                                     'types': {'plug': 'MPlug',
                                                               'plugValue': 'float'}}],
                              'newPlugValueInt': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                        'type': 'MPlug'},
                                                               'plugValue': {'doc': 'the value to set',
                                                                             'type': 'int'}},
                                                   'args': [('plug',
                                                             'MPlug',
                                                             'in'),
                                                            ('plugValue',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to an int value.',
                                                   'inArgs': ['plug',
                                                              'plugValue'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'plug': ['const',
                                                                               '&'],
                                                                      'plugValue': []},
                                                   'types': {'plug': 'MPlug',
                                                             'plugValue': 'int'}}],
                              'newPlugValueInt64': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                          'type': 'MPlug'},
                                                                 'plugValue': {'doc': 'the value to set',
                                                                               'type': 'MInt64'}},
                                                     'args': [('plug',
                                                               'MPlug',
                                                               'in'),
                                                              ('plugValue',
                                                               'MInt64',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to a 64-bit int value.',
                                                     'inArgs': ['plug',
                                                                'plugValue'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'plug': ['const',
                                                                                 '&'],
                                                                        'plugValue': []},
                                                     'types': {'plug': 'MPlug',
                                                               'plugValue': 'MInt64'}}],
                              'newPlugValueMAngle': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                           'type': 'MPlug'},
                                                                  'plugValue': {'doc': 'the value to set',
                                                                                'type': 'MAngle'}},
                                                      'args': [('plug',
                                                                'MPlug',
                                                                'in'),
                                                               ('plugValue',
                                                                'MAngle',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to an  MAngle  value.',
                                                      'inArgs': ['plug',
                                                                 'plugValue'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'plug': ['const',
                                                                                  '&'],
                                                                         'plugValue': ['const',
                                                                                       '&']},
                                                      'types': {'plug': 'MPlug',
                                                                'plugValue': 'MAngle'}}],
                              'newPlugValueMDistance': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                              'type': 'MPlug'},
                                                                     'plugValue': {'doc': 'the value to set',
                                                                                   'type': 'MDistance'}},
                                                         'args': [('plug',
                                                                   'MPlug',
                                                                   'in'),
                                                                  ('plugValue',
                                                                   'MDistance',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to an  MDistance  value.',
                                                         'inArgs': ['plug',
                                                                    'plugValue'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'plug': ['const',
                                                                                     '&'],
                                                                            'plugValue': ['const',
                                                                                          '&']},
                                                         'types': {'plug': 'MPlug',
                                                                   'plugValue': 'MDistance'}}],
                              'newPlugValueMTime': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                          'type': 'MPlug'},
                                                                 'plugValue': {'doc': 'the value to set',
                                                                               'type': 'MTime'}},
                                                     'args': [('plug',
                                                               'MPlug',
                                                               'in'),
                                                              ('plugValue',
                                                               'MTime',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to an  MTime  value.',
                                                     'inArgs': ['plug',
                                                                'plugValue'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'plug': ['const',
                                                                                 '&'],
                                                                        'plugValue': ['const',
                                                                                      '&']},
                                                     'types': {'plug': 'MPlug',
                                                               'plugValue': 'MTime'}}],
                              'newPlugValueShort': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                          'type': 'MPlug'},
                                                                 'plugValue': {'doc': 'the value to set',
                                                                               'type': 'short'}},
                                                     'args': [('plug',
                                                               'MPlug',
                                                               'in'),
                                                              ('plugValue',
                                                               'short',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to a short value.',
                                                     'inArgs': ['plug',
                                                                'plugValue'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'plug': ['const',
                                                                                 '&'],
                                                                        'plugValue': []},
                                                     'types': {'plug': 'MPlug',
                                                               'plugValue': 'short'}}],
                              'newPlugValueString': [{'argInfo': {'plug': {'doc': 'the plug to set ',
                                                                           'type': 'MPlug'},
                                                                  'plugValue': {'doc': 'the value to set',
                                                                                'type': 'MString'}},
                                                      'args': [('plug',
                                                                'MPlug',
                                                                'in'),
                                                               ('plugValue',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdds an operation to this dependency graph modifier that sets a plug to a string value.',
                                                      'inArgs': ['plug',
                                                                 'plugValue'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'plug': ['const',
                                                                                  '&'],
                                                                         'plugValue': ['const',
                                                                                       '&']},
                                                      'types': {'plug': 'MPlug',
                                                                'plugValue': 'MString'}}],
                              'pythonCommandToExecute': [{'argInfo': {'command': {'doc': 'the command that will be executed (should be undoable)',
                                                                                  'type': 'MString'}},
                                                          'args': [('command',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nAdds an operation to this dependency graph modifier that executes a Python command/script.',
                                                          'inArgs': ['command'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'command': ['const',
                                                                                         '&']},
                                                          'types': {'command': 'MString'}}],
                              'removeAttribute': [{'argInfo': {'attribute': {'doc': 'attribute to add',
                                                                             'type': 'MObject'},
                                                               'node': {'doc': 'node to add an attribute to ',
                                                                        'type': 'MObject'}},
                                                   'args': [('node',
                                                             'MObject',
                                                             'in'),
                                                            ('attribute',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRemoves a dynamic attribute from the given dependency node.',
                                                   'inArgs': ['node',
                                                              'attribute'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'attribute': ['const',
                                                                                    '&'],
                                                                      'node': ['const',
                                                                               '&']},
                                                   'types': {'attribute': 'MObject',
                                                             'node': 'MObject'}},
                                                  {'argInfo': {'attribute': {'doc': 'attribute to add ',
                                                                             'type': 'MObject'},
                                                               'node': {'doc': 'node to add an attribute to ',
                                                                        'type': 'MObject'},
                                                               'type': {'doc': 'determines if this is a local or global attribute',
                                                                        'type': ('MFnDependencyNode',
                                                                                 'MAttrClass')}},
                                                   'args': [('node',
                                                             'MObject',
                                                             'in'),
                                                            ('attribute',
                                                             'MObject',
                                                             'in'),
                                                            ('type',
                                                             ('MFnDependencyNode',
                                                              'MAttrClass'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': True,
                                                   'doc': '\n Deprecated: Use  MDGModifier::removeAttribute( const MObject&, const MObject& )  instead \r\nRemoves a dynamic attribute from the given dependency node.',
                                                   'inArgs': ['node',
                                                              'attribute',
                                                              'type'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'attribute': ['const',
                                                                                    '&'],
                                                                      'node': ['const',
                                                                               '&'],
                                                                      'type': []},
                                                   'types': {'attribute': 'MObject',
                                                             'node': 'MObject',
                                                             'type': ('MFnDependencyNode',
                                                                      'MAttrClass')}}],
                              'removeExtensionAttribute': [{'argInfo': {'attribute': {'doc': 'attribute to remove',
                                                                                      'type': 'MObject'},
                                                                        'nodeClass': {'doc': 'class of node from which to remove the attribute ',
                                                                                      'type': 'MNodeClass'}},
                                                            'args': [('nodeClass',
                                                                      'MNodeClass',
                                                                      'in'),
                                                                     ('attribute',
                                                                      'MObject',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nRemoves an extension attribute from the given dependency node type.',
                                                            'inArgs': ['nodeClass',
                                                                       'attribute'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'attribute': ['const',
                                                                                             '&'],
                                                                               'nodeClass': ['const',
                                                                                             '&']},
                                                            'types': {'attribute': 'MObject',
                                                                      'nodeClass': 'MNodeClass'}}],
                              'removeExtensionAttributeIfUnset': [{'argInfo': {'attribute': {'doc': 'attribute to remove',
                                                                                             'type': 'MObject'},
                                                                               'nodeClass': {'doc': 'class of node from which to remove the attribute ',
                                                                                             'type': 'MNodeClass'}},
                                                                   'args': [('nodeClass',
                                                                             'MNodeClass',
                                                                             'in'),
                                                                            ('attribute',
                                                                             'MObject',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nRemoves an extension attribute from the given dependency node type but only if there are no nodes in the graph with non-default values for this attribute.',
                                                                   'inArgs': ['nodeClass',
                                                                              'attribute'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'attribute': ['const',
                                                                                                    '&'],
                                                                                      'nodeClass': ['const',
                                                                                                    '&']},
                                                                   'types': {'attribute': 'MObject',
                                                                             'nodeClass': 'MNodeClass'}}],
                              'removeMultiInstance': [{'argInfo': {'breakConnections': {'doc': 'whether to break connections before removing the element',
                                                                                        'type': 'bool'},
                                                                   'plug': {'doc': 'the plug to remove ',
                                                                            'type': 'MPlug'}},
                                                       'args': [('plug',
                                                                 'MPlug',
                                                                 'in'),
                                                                ('breakConnections',
                                                                 'bool',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nAdds an operation to this dependency graph modifier that removes an element of a multi (array) plug.',
                                                       'inArgs': ['plug',
                                                                  'breakConnections'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'breakConnections': [],
                                                                          'plug': ['const',
                                                                                   '&']},
                                                       'types': {'breakConnections': 'bool',
                                                                 'plug': 'MPlug'}}],
                              'renameAttribute': [{'argInfo': {'attribute': {'doc': 'The attribute to rename ',
                                                                             'type': 'MObject'},
                                                               'longName': {'doc': 'The new long name',
                                                                            'type': 'MString'},
                                                               'node': {'doc': 'The node to which the attribute belongs ',
                                                                        'type': 'MObject'},
                                                               'shortName': {'doc': 'The new short name ',
                                                                             'type': 'MString'}},
                                                   'args': [('node',
                                                             'MObject',
                                                             'in'),
                                                            ('attribute',
                                                             'MObject',
                                                             'in'),
                                                            ('shortName',
                                                             'MString',
                                                             'in'),
                                                            ('longName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRenames a dynamic attribute on the given dependency node.',
                                                   'inArgs': ['node',
                                                              'attribute',
                                                              'shortName',
                                                              'longName'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'attribute': ['const',
                                                                                    '&'],
                                                                      'longName': ['const',
                                                                                   '&'],
                                                                      'node': ['const',
                                                                               '&'],
                                                                      'shortName': ['const',
                                                                                    '&']},
                                                   'types': {'attribute': 'MObject',
                                                             'longName': 'MString',
                                                             'node': 'MObject',
                                                             'shortName': 'MString'}}],
                              'renameNode': [{'argInfo': {'newName': {'doc': 'new name for the node',
                                                                      'type': 'MString'},
                                                          'node': {'doc': 'node to rename ',
                                                                   'type': 'MObject'}},
                                              'args': [('node',
                                                        'MObject',
                                                        'in'),
                                                       ('newName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method adds an operation to this dependency graph modifier that will rename a dependency graph node.',
                                              'inArgs': ['node',
                                                         'newName'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'newName': ['const',
                                                                             '&'],
                                                                 'node': ['const',
                                                                          '&']},
                                              'types': {'newName': 'MString',
                                                        'node': 'MObject'}}],
                              'setMetadata': [{'argInfo': {'metadata': {'doc': 'The metadata values it will receive',
                                                                        'type': ('adsk',
                                                                                 'Data',
                                                                                 'Associations')},
                                                           'node': {'doc': 'The node to receive the metadata ',
                                                                    'type': 'MObject'}},
                                               'args': [('node',
                                                         'MObject',
                                                         'in'),
                                                        ('metadata',
                                                         ('adsk',
                                                          'Data',
                                                          'Associations'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nAdds an operation to this dependency graph modifier that replaces metadata on a specific node.',
                                               'inArgs': ['node',
                                                          'metadata'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'metadata': ['const',
                                                                               '&'],
                                                                  'node': ['const',
                                                                           '&']},
                                               'types': {'metadata': ('adsk',
                                                                      'Data',
                                                                      'Associations'),
                                                         'node': 'MObject'}}],
                              'setNodeLockState': [{'argInfo': {'newState': {'doc': 'new lock state',
                                                                             'type': 'bool'},
                                                                'node': {'doc': 'node to toggle lock state ',
                                                                         'type': 'MObject'}},
                                                    'args': [('node',
                                                              'MObject',
                                                              'in'),
                                                             ('newState',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis method adds an operation to this dependency graph modifier that will set the lock state of the node.',
                                                    'inArgs': ['node',
                                                               'newState'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'newState': [],
                                                                       'node': ['const',
                                                                                '&']},
                                                    'types': {'newState': 'bool',
                                                              'node': 'MObject'}}],
                              'undoIt': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nUndoes all of the operations that have been given to this modifier. It is only valid to call this method after the doIt method has been called.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'unlinkExtensionAttributeFromPlugin': [{'argInfo': {'mAttribute': {'doc': 'attribute to disassociate with the plugin, must not have a parent',
                                                                                                 'type': 'MObject'},
                                                                                  'mPlugin': {'doc': 'plugin from which the attribute is to be released ',
                                                                                              'type': 'MObject'}},
                                                                      'args': [('mPlugin',
                                                                                'MObject',
                                                                                'in'),
                                                                               ('mAttribute',
                                                                                'MObject',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\r\nTells a plugin that it no longer requires an extension attribute for operation. This requirement is used when the plugin is checked to see if it is in use or if is able to be unloaded.',
                                                                      'inArgs': ['mPlugin',
                                                                                 'mAttribute'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': None},
                                                                      'returnType': None,
                                                                      'static': False,
                                                                      'typeQualifiers': {'mAttribute': ['const',
                                                                                                        '&'],
                                                                                         'mPlugin': ['const',
                                                                                                     '&']},
                                                                      'types': {'mAttribute': 'MObject',
                                                                                'mPlugin': 'MObject'}}]},
                  'pymelEnums': {}},
  'MDagMessage': {'enums': {'DagMessage': {'valueDocs': {'childAdded': 'a child was added to a DAG node',
                                                         'childRemoved': 'a child was removed from a DAG node',
                                                         'childReordered': 'a child of a DAG node was reordered',
                                                         'instanceAdded': 'a DAG node was instanced',
                                                         'instanceRemoved': 'a DAG node instance was removed',
                                                         'invalidMsg': 'an invalid message was used.',
                                                         'kChildAdded': 'a child was added to a DAG node',
                                                         'kChildRemoved': 'a child was removed from a DAG node',
                                                         'kChildReordered': 'a child of a DAG node was reordered',
                                                         'kInstanceAdded': 'a DAG node was instanced',
                                                         'kInstanceRemoved': 'a DAG node instance was removed',
                                                         'kInvalidMsg': 'an invalid message was used.',
                                                         'kLast': 'last value of the enum',
                                                         'kParentAdded': 'a dummy enum used for looping through the message types',
                                                         'kParentRemoved': 'a parent was removed from a DAG node',
                                                         'last': 'last value of the enum',
                                                         'parentAdded': 'a dummy enum used for looping through the message types',
                                                         'parentRemoved': 'a parent was removed from a DAG node'},
                                           'values': "Enum('DagMessage', {'kInvalidMsg': -1, 'kParentAdded': 0, 'kParentRemoved': 1, 'kChildAdded': 2, 'kChildRemoved': 3, 'kChildReordered': 4, 'kInstanceAdded': 5, 'kInstanceRemoved': 6, 'kLast': 7})"}},
                  'methods': {'addAllDagChangesCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                       'type': 'void'},
                                                                        'func': {'doc': 'the callback function',
                                                                                 'type': ('MDagMessage',
                                                                                          'MMessageParentChildFunction')}},
                                                            'args': [('func',
                                                                      ('MDagMessage',
                                                                       'MMessageParentChildFunction'),
                                                                      'in'),
                                                                     ('clientData',
                                                                      'void',
                                                                      'in')],
                                                            'defaults': {'clientData': None},
                                                            'deprecated': False,
                                                            'doc': '\r\nThis method registers a callback that is called whenever any DAG change is made to any DAG node.',
                                                            'inArgs': ['func',
                                                                       'clientData'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                           'qualifiers': [],
                                                                           'type': 'MCallbackId'},
                                                            'returnType': 'MCallbackId',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'clientData': ['*'],
                                                                               'func': []},
                                                            'types': {'clientData': 'void',
                                                                      'func': ('MDagMessage',
                                                                               'MMessageParentChildFunction')}}],
                              'addAllDagChangesDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function. ',
                                                                                              'type': 'void'},
                                                                               'func': {'doc': 'The callback function.',
                                                                                        'type': ('MDagMessage',
                                                                                                 'MMessageParentChildFunction')},
                                                                               'node': {'doc': 'The DAG node to register the callback for. ',
                                                                                        'type': 'MDagPath'}},
                                                                   'args': [('node',
                                                                             'MDagPath',
                                                                             'in'),
                                                                            ('func',
                                                                             ('MDagMessage',
                                                                              'MMessageParentChildFunction'),
                                                                             'in'),
                                                                            ('clientData',
                                                                             'void',
                                                                             'in')],
                                                                   'defaults': {'clientData': None},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nThis method registers a callback that is called whenever a DAG change is made to the specified DAG path.',
                                                                   'inArgs': ['node',
                                                                              'func',
                                                                              'clientData'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MCallbackId'},
                                                                   'returnType': 'MCallbackId',
                                                                   'static': True,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'clientData': ['*'],
                                                                                      'func': [],
                                                                                      'node': ['&']},
                                                                   'types': {'clientData': 'void',
                                                                             'func': ('MDagMessage',
                                                                                      'MMessageParentChildFunction'),
                                                                             'node': 'MDagPath'}}],
                              'addChildAddedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                    'type': 'void'},
                                                                     'func': {'doc': 'the callback function',
                                                                              'type': ('MMessage',
                                                                                       'MParentChildFunction')}},
                                                         'args': [('func',
                                                                   ('MMessage',
                                                                    'MParentChildFunction'),
                                                                   'in'),
                                                                  ('clientData',
                                                                   'void',
                                                                   'in')],
                                                         'defaults': {'clientData': None},
                                                         'deprecated': False,
                                                         'doc': '\r\nThis method registers a callback that is called whenever a child is added in the DAG.',
                                                         'inArgs': ['func',
                                                                    'clientData'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                        'qualifiers': [],
                                                                        'type': 'MCallbackId'},
                                                         'returnType': 'MCallbackId',
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'clientData': ['*'],
                                                                            'func': []},
                                                         'types': {'clientData': 'void',
                                                                   'func': ('MMessage',
                                                                            'MParentChildFunction')}}],
                              'addChildAddedDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                           'type': 'void'},
                                                                            'func': {'doc': 'the callback function',
                                                                                     'type': ('MMessage',
                                                                                              'MParentChildFunction')},
                                                                            'node': {'doc': 'The DAG node to register the callback for ',
                                                                                     'type': 'MDagPath'}},
                                                                'args': [('node',
                                                                          'MDagPath',
                                                                          'in'),
                                                                         ('func',
                                                                          ('MMessage',
                                                                           'MParentChildFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': '\r\nThis method registers a callback that is called whenever a child is added to the specified DAG node.',
                                                                'inArgs': ['node',
                                                                           'func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'func': [],
                                                                                   'node': ['&']},
                                                                'types': {'clientData': 'void',
                                                                          'func': ('MMessage',
                                                                                   'MParentChildFunction'),
                                                                          'node': 'MDagPath'}}],
                              'addChildRemovedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                      'type': 'void'},
                                                                       'func': {'doc': 'the callback function',
                                                                                'type': ('MMessage',
                                                                                         'MParentChildFunction')}},
                                                           'args': [('func',
                                                                     ('MMessage',
                                                                      'MParentChildFunction'),
                                                                     'in'),
                                                                    ('clientData',
                                                                     'void',
                                                                     'in')],
                                                           'defaults': {'clientData': None},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method registers a callback that is called whenever a child is removed in the DAG.',
                                                           'inArgs': ['func',
                                                                      'clientData'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                          'qualifiers': [],
                                                                          'type': 'MCallbackId'},
                                                           'returnType': 'MCallbackId',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'clientData': ['*'],
                                                                              'func': []},
                                                           'types': {'clientData': 'void',
                                                                     'func': ('MMessage',
                                                                              'MParentChildFunction')}}],
                              'addChildRemovedDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                             'type': 'void'},
                                                                              'func': {'doc': 'the callback function',
                                                                                       'type': ('MMessage',
                                                                                                'MParentChildFunction')},
                                                                              'node': {'doc': 'The DAG node to register the callback for ',
                                                                                       'type': 'MDagPath'}},
                                                                  'args': [('node',
                                                                            'MDagPath',
                                                                            'in'),
                                                                           ('func',
                                                                            ('MMessage',
                                                                             'MParentChildFunction'),
                                                                            'in'),
                                                                           ('clientData',
                                                                            'void',
                                                                            'in')],
                                                                  'defaults': {'clientData': None},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nThis method registers a callback that is called whenever a child is removed from the specified DAG node.',
                                                                  'inArgs': ['node',
                                                                             'func',
                                                                             'clientData'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'MCallbackId'},
                                                                  'returnType': 'MCallbackId',
                                                                  'static': True,
                                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                     'clientData': ['*'],
                                                                                     'func': [],
                                                                                     'node': ['&']},
                                                                  'types': {'clientData': 'void',
                                                                            'func': ('MMessage',
                                                                                     'MParentChildFunction'),
                                                                            'node': 'MDagPath'}}],
                              'addChildReorderedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                        'type': 'void'},
                                                                         'func': {'doc': 'the callback function',
                                                                                  'type': ('MMessage',
                                                                                           'MParentChildFunction')}},
                                                             'args': [('func',
                                                                       ('MMessage',
                                                                        'MParentChildFunction'),
                                                                       'in'),
                                                                      ('clientData',
                                                                       'void',
                                                                       'in')],
                                                             'defaults': {'clientData': None},
                                                             'deprecated': False,
                                                             'doc': '\r\nThis method registers a callback that is called whenever a child is reordered in the DAG.',
                                                             'inArgs': ['func',
                                                                        'clientData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'clientData': ['*'],
                                                                                'func': []},
                                                             'types': {'clientData': 'void',
                                                                       'func': ('MMessage',
                                                                                'MParentChildFunction')}}],
                              'addChildReorderedDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                               'type': 'void'},
                                                                                'func': {'doc': 'the callback function',
                                                                                         'type': ('MMessage',
                                                                                                  'MParentChildFunction')},
                                                                                'node': {'doc': 'The DAG node to register the callback for ',
                                                                                         'type': 'MDagPath'}},
                                                                    'args': [('node',
                                                                              'MDagPath',
                                                                              'in'),
                                                                             ('func',
                                                                              ('MMessage',
                                                                               'MParentChildFunction'),
                                                                              'in'),
                                                                             ('clientData',
                                                                              'void',
                                                                              'in')],
                                                                    'defaults': {'clientData': None},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nThis method registers a callback that is called whenever a child of the specified DAG node is reordered.',
                                                                    'inArgs': ['node',
                                                                               'func',
                                                                               'clientData'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                   'qualifiers': [],
                                                                                   'type': 'MCallbackId'},
                                                                    'returnType': 'MCallbackId',
                                                                    'static': True,
                                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                       'clientData': ['*'],
                                                                                       'func': [],
                                                                                       'node': ['&']},
                                                                    'types': {'clientData': 'void',
                                                                              'func': ('MMessage',
                                                                                       'MParentChildFunction'),
                                                                              'node': 'MDagPath'}}],
                              'addDagDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function. ',
                                                                                    'type': 'void'},
                                                                     'func': {'doc': 'The callback function.',
                                                                              'type': ('MDagMessage',
                                                                                       'MMessageParentChildFunction')},
                                                                     'msgType': {'doc': 'The type of DAG change to trigger the callback. ',
                                                                                 'type': ('MDagMessage',
                                                                                          'DagMessage')},
                                                                     'node': {'doc': 'The DAG node to register the callback for. ',
                                                                              'type': 'MDagPath'}},
                                                         'args': [('node',
                                                                   'MDagPath',
                                                                   'in'),
                                                                  ('msgType',
                                                                   ('MDagMessage',
                                                                    'DagMessage'),
                                                                   'in'),
                                                                  ('func',
                                                                   ('MDagMessage',
                                                                    'MMessageParentChildFunction'),
                                                                   'in'),
                                                                  ('clientData',
                                                                   'void',
                                                                   'in')],
                                                         'defaults': {'clientData': None},
                                                         'deprecated': False,
                                                         'doc': '\r\nThis method registers a callback that is called for specified a DAG change is made to the specified DAG path. The callback receives the DagMessage as well.',
                                                         'inArgs': ['node',
                                                                    'msgType',
                                                                    'func',
                                                                    'clientData'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                        'qualifiers': [],
                                                                        'type': 'MCallbackId'},
                                                         'returnType': 'MCallbackId',
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'clientData': ['*'],
                                                                            'func': [],
                                                                            'msgType': [],
                                                                            'node': ['&']},
                                                         'types': {'clientData': 'void',
                                                                   'func': ('MDagMessage',
                                                                            'MMessageParentChildFunction'),
                                                                   'msgType': ('MDagMessage',
                                                                               'DagMessage'),
                                                                   'node': 'MDagPath'}}],
                              'addInstanceAddedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                       'type': 'void'},
                                                                        'func': {'doc': 'the callback function',
                                                                                 'type': ('MMessage',
                                                                                          'MParentChildFunction')}},
                                                            'args': [('func',
                                                                      ('MMessage',
                                                                       'MParentChildFunction'),
                                                                      'in'),
                                                                     ('clientData',
                                                                      'void',
                                                                      'in')],
                                                            'defaults': {'clientData': None},
                                                            'deprecated': False,
                                                            'doc': '\r\nThis method registers a callback that is called whenever any node in the DAG is instanced',
                                                            'inArgs': ['func',
                                                                       'clientData'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                           'qualifiers': [],
                                                                           'type': 'MCallbackId'},
                                                            'returnType': 'MCallbackId',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'clientData': ['*'],
                                                                               'func': []},
                                                            'types': {'clientData': 'void',
                                                                      'func': ('MMessage',
                                                                               'MParentChildFunction')}}],
                              'addInstanceAddedDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function. ',
                                                                                              'type': 'void'},
                                                                               'func': {'doc': 'The callback function.',
                                                                                        'type': ('MMessage',
                                                                                                 'MParentChildFunction')},
                                                                               'node': {'doc': 'The DAG node to register the callback for. ',
                                                                                        'type': 'MDagPath'}},
                                                                   'args': [('node',
                                                                             'MDagPath',
                                                                             'in'),
                                                                            ('func',
                                                                             ('MMessage',
                                                                              'MParentChildFunction'),
                                                                             'in'),
                                                                            ('clientData',
                                                                             'void',
                                                                             'in')],
                                                                   'defaults': {'clientData': None},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nThis method registers a callback that is called whenever the specified node is instanced',
                                                                   'inArgs': ['node',
                                                                              'func',
                                                                              'clientData'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MCallbackId'},
                                                                   'returnType': 'MCallbackId',
                                                                   'static': True,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'clientData': ['*'],
                                                                                      'func': [],
                                                                                      'node': ['&']},
                                                                   'types': {'clientData': 'void',
                                                                             'func': ('MMessage',
                                                                                      'MParentChildFunction'),
                                                                             'node': 'MDagPath'}}],
                              'addInstanceRemovedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                         'type': 'void'},
                                                                          'func': {'doc': 'the callback function',
                                                                                   'type': ('MMessage',
                                                                                            'MParentChildFunction')}},
                                                              'args': [('func',
                                                                        ('MMessage',
                                                                         'MParentChildFunction'),
                                                                        'in'),
                                                                       ('clientData',
                                                                        'void',
                                                                        'in')],
                                                              'defaults': {'clientData': None},
                                                              'deprecated': False,
                                                              'doc': '\r\nThis method registers a callback that is called whenever an instance of any DAG node is removed or deleted.',
                                                              'inArgs': ['func',
                                                                         'clientData'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                             'qualifiers': [],
                                                                             'type': 'MCallbackId'},
                                                              'returnType': 'MCallbackId',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'clientData': ['*'],
                                                                                 'func': []},
                                                              'types': {'clientData': 'void',
                                                                        'func': ('MMessage',
                                                                                 'MParentChildFunction')}}],
                              'addInstanceRemovedDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function. ',
                                                                                                'type': 'void'},
                                                                                 'func': {'doc': 'The callback function.',
                                                                                          'type': ('MMessage',
                                                                                                   'MParentChildFunction')},
                                                                                 'node': {'doc': 'The DAG node to register the callback for. ',
                                                                                          'type': 'MDagPath'}},
                                                                     'args': [('node',
                                                                               'MDagPath',
                                                                               'in'),
                                                                              ('func',
                                                                               ('MMessage',
                                                                                'MParentChildFunction'),
                                                                               'in'),
                                                                              ('clientData',
                                                                               'void',
                                                                               'in')],
                                                                     'defaults': {'clientData': None},
                                                                     'deprecated': False,
                                                                     'doc': '\r\nThis method registers a callback that is called whenever an instance of the specified node is removed.',
                                                                     'inArgs': ['node',
                                                                                'func',
                                                                                'clientData'],
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                    'qualifiers': [],
                                                                                    'type': 'MCallbackId'},
                                                                     'returnType': 'MCallbackId',
                                                                     'static': True,
                                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                        'clientData': ['*'],
                                                                                        'func': [],
                                                                                        'node': ['&']},
                                                                     'types': {'clientData': 'void',
                                                                               'func': ('MMessage',
                                                                                        'MParentChildFunction'),
                                                                               'node': 'MDagPath'}}],
                              'addParentAddedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                     'type': 'void'},
                                                                      'func': {'doc': 'the callback function',
                                                                               'type': ('MMessage',
                                                                                        'MParentChildFunction')}},
                                                          'args': [('func',
                                                                    ('MMessage',
                                                                     'MParentChildFunction'),
                                                                    'in'),
                                                                   ('clientData',
                                                                    'void',
                                                                    'in')],
                                                          'defaults': {'clientData': None},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis method registers a callback that is called whenever a parent is added in the DAG.',
                                                          'inArgs': ['func',
                                                                     'clientData'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                         'qualifiers': [],
                                                                         'type': 'MCallbackId'},
                                                          'returnType': 'MCallbackId',
                                                          'static': True,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'clientData': ['*'],
                                                                             'func': []},
                                                          'types': {'clientData': 'void',
                                                                    'func': ('MMessage',
                                                                             'MParentChildFunction')}}],
                              'addParentAddedDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                            'type': 'void'},
                                                                             'func': {'doc': 'the callback function',
                                                                                      'type': ('MMessage',
                                                                                               'MParentChildFunction')},
                                                                             'node': {'doc': 'The DAG node to register the callback for ',
                                                                                      'type': 'MDagPath'}},
                                                                 'args': [('node',
                                                                           'MDagPath',
                                                                           'in'),
                                                                          ('func',
                                                                           ('MMessage',
                                                                            'MParentChildFunction'),
                                                                           'in'),
                                                                          ('clientData',
                                                                           'void',
                                                                           'in')],
                                                                 'defaults': {'clientData': None},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nThis method registers a callback that is called whenever a parent is added to the specified DAG node..',
                                                                 'inArgs': ['node',
                                                                            'func',
                                                                            'clientData'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                'qualifiers': [],
                                                                                'type': 'MCallbackId'},
                                                                 'returnType': 'MCallbackId',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'clientData': ['*'],
                                                                                    'func': [],
                                                                                    'node': ['&']},
                                                                 'types': {'clientData': 'void',
                                                                           'func': ('MMessage',
                                                                                    'MParentChildFunction'),
                                                                           'node': 'MDagPath'}}],
                              'addParentRemovedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                       'type': 'void'},
                                                                        'func': {'doc': 'the callback function',
                                                                                 'type': ('MMessage',
                                                                                          'MParentChildFunction')}},
                                                            'args': [('func',
                                                                      ('MMessage',
                                                                       'MParentChildFunction'),
                                                                      'in'),
                                                                     ('clientData',
                                                                      'void',
                                                                      'in')],
                                                            'defaults': {'clientData': None},
                                                            'deprecated': False,
                                                            'doc': '\r\nThis method registers a callback that is called whenever a parent is removed in the DAG.',
                                                            'inArgs': ['func',
                                                                       'clientData'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                           'qualifiers': [],
                                                                           'type': 'MCallbackId'},
                                                            'returnType': 'MCallbackId',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'clientData': ['*'],
                                                                               'func': []},
                                                            'types': {'clientData': 'void',
                                                                      'func': ('MMessage',
                                                                               'MParentChildFunction')}}],
                              'addParentRemovedDagPathCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                              'type': 'void'},
                                                                               'func': {'doc': 'the callback function',
                                                                                        'type': ('MMessage',
                                                                                                 'MParentChildFunction')},
                                                                               'node': {'doc': 'The DAG node to register the callback for ',
                                                                                        'type': 'MDagPath'}},
                                                                   'args': [('node',
                                                                             'MDagPath',
                                                                             'in'),
                                                                            ('func',
                                                                             ('MMessage',
                                                                              'MParentChildFunction'),
                                                                             'in'),
                                                                            ('clientData',
                                                                             'void',
                                                                             'in')],
                                                                   'defaults': {'clientData': None},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nThis method registers a callback that is called whenever a parent is removed from the specified DAG node.',
                                                                   'inArgs': ['node',
                                                                              'func',
                                                                              'clientData'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MCallbackId'},
                                                                   'returnType': 'MCallbackId',
                                                                   'static': True,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'clientData': ['*'],
                                                                                      'func': [],
                                                                                      'node': ['&']},
                                                                   'types': {'clientData': 'void',
                                                                             'func': ('MMessage',
                                                                                      'MParentChildFunction'),
                                                                             'node': 'MDagPath'}}],
                              'addWorldMatrixModifiedCallback': [{'argInfo': {'affectedNode': {'doc': 'The DAG node to register the callback for. ',
                                                                                               'type': 'MDagPath'},
                                                                              'clientData': {'doc': 'User defined data passed to the callback function. ',
                                                                                             'type': 'void'},
                                                                              'func': {'doc': "The callback function.  triggerNode The node whose transformation changed  flag How the trigger node's transformation changed  clientData User defined data passed to the callback function.   ",
                                                                                       'type': ('MDagMessage',
                                                                                                'MWorldMatrixModifiedFunction')}},
                                                                  'args': [('affectedNode',
                                                                            'MDagPath',
                                                                            'in'),
                                                                           ('func',
                                                                            ('MDagMessage',
                                                                             'MWorldMatrixModifiedFunction'),
                                                                            'in'),
                                                                           ('clientData',
                                                                            'void',
                                                                            'in')],
                                                                  'defaults': {'clientData': None},
                                                                  'deprecated': False,
                                                                  'doc': "\r\nThis method registers a callback that is called when a DAG node's worldMatrix changes.",
                                                                  'inArgs': ['affectedNode',
                                                                             'func',
                                                                             'clientData'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'MCallbackId'},
                                                                  'returnType': 'MCallbackId',
                                                                  'static': True,
                                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                     'affectedNode': ['&'],
                                                                                     'clientData': ['*'],
                                                                                     'func': []},
                                                                  'types': {'affectedNode': 'MDagPath',
                                                                            'clientData': 'void',
                                                                            'func': ('MDagMessage',
                                                                                     'MWorldMatrixModifiedFunction')}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                  'pymelEnums': {'DagMessage': "Enum('DagMessage', [('invalidMsg', -1), ('kInvalidMsg', -1), ('parentAdded', 0), ('kParentAdded', 0), ('parentRemoved', 1), ('kParentRemoved', 1), ('childAdded', 2), ('kChildAdded', 2), ('childRemoved', 3), ('kChildRemoved', 3), ('childReordered', 4), ('kChildReordered', 4), ('instanceAdded', 5), ('kInstanceAdded', 5), ('instanceRemoved', 6), ('kInstanceRemoved', 6), ('last', 7), ('kLast', 7)], multiKeys=True)"}},
  'MDagModifier': {'enums': {},
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'createNode': [{'argInfo': {'parent': {'doc': 'parent object in the DAG ',
                                                                      'type': 'MObject'},
                                                           'typeId': {'doc': 'type of the node to create ',
                                                                      'type': 'MTypeId'}},
                                               'args': [('typeId',
                                                         'MTypeId',
                                                         'in'),
                                                        ('parent',
                                                         'MObject',
                                                         'in')],
                                               'defaults': {'parent': 'MObject::kNullObj'},
                                               'deprecated': False,
                                               'doc': '\r\nThis method adds an operation to this DAG modifier that will add a new node of the given type to the DAG. This method may not be used to construct new dependency graph nodes that are not in the DAG. Use  MDGModifier  for that purpose.',
                                               'inArgs': ['typeId',
                                                          'parent'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A handle for the new node, or the transform above if one is created as a parent.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'parent': ['const',
                                                                             '&'],
                                                                  'typeId': ['const',
                                                                             '&']},
                                               'types': {'parent': 'MObject',
                                                         'typeId': 'MTypeId'}},
                                              {'argInfo': {'parent': {'doc': 'parent object in the DAG ',
                                                                      'type': 'MObject'},
                                                           'type': {'doc': 'type of the node to create ',
                                                                    'type': 'MString'}},
                                               'args': [('type',
                                                         'MString',
                                                         'in'),
                                                        ('parent',
                                                         'MObject',
                                                         'in')],
                                               'defaults': {'parent': 'MObject::kNullObj'},
                                               'deprecated': False,
                                               'doc': '\r\nThis method adds an operation to this DAG modifier that will add a new node of the given type to the DAG. This method may not be used to construct new dependency graph nodes that are not in the DAG. Use  MDGModifier  for that purpose.',
                                               'inArgs': ['type',
                                                          'parent'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A handle for the new node, or the transform above if one is created as a parent.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'parent': ['const',
                                                                             '&'],
                                                                  'type': ['const',
                                                                           '&']},
                                               'types': {'parent': 'MObject',
                                                         'type': 'MString'}}],
                               'reparentNode': [{'argInfo': {'newParent': {'doc': 'new parent for the node',
                                                                           'type': 'MObject'},
                                                             'node': {'doc': 'node to reparent ',
                                                                      'type': 'MObject'}},
                                                 'args': [('node',
                                                           'MObject',
                                                           'in'),
                                                          ('newParent',
                                                           'MObject',
                                                           'out')],
                                                 'defaults': {'newParent': 'MObject::kNullObj'},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method adds an operation to this DAG modifier that will reparent a node in the DAG. If the parent passed in is NULL, then the node will be reparented under the world.',
                                                 'inArgs': ['node'],
                                                 'outArgs': ['newParent'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'newParent': ['const',
                                                                                  '&'],
                                                                    'node': ['const',
                                                                             '&']},
                                                 'types': {'newParent': 'MObject',
                                                           'node': 'MObject'}}]},
                   'pymelEnums': {}},
  'MDagPath': {'enums': {},
               'methods': {'__eq__': [{'argInfo': {'src': {'doc': 'The path to be compared.',
                                                           'type': 'MDagPath'}},
                                       'args': [('src',
                                                 'MDagPath',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nDetermines if the DAG Path on the LHS of the operator is equal to the DAG Path on the RHS.',
                                       'inArgs': ['src'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'True is the objects are equal ',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'src': ['const',
                                                                  '&']},
                                       'types': {'src': 'MDagPath'}}],
                           'apiType': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the type of the object at the end of the path.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'Type of the object',
                                                       'qualifiers': [],
                                                       'type': ('MFn',
                                                                'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                           'child': [{'argInfo': {'index': {'doc': "child's index ",
                                                            'type': 'uint'}},
                                      'args': [('index', 'uint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn the child object at the given index, where the parent is the object at the end of the path.',
                                      'inArgs': ['index'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A handle to the child',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'index': ['unsigned']},
                                      'types': {'index': 'uint'}}],
                           'childCount': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the number of children that the object at the end of the path has.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of children',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                           'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'exclusiveMatrix': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines the exclusive matrix of the Path.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The matrix for all transforms in the Path excluding the end Node in the Path if it is Transform',
                                                               'qualifiers': [],
                                                               'type': 'MMatrix'},
                                                'returnType': 'MMatrix',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                           'exclusiveMatrixInverse': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nDetermines the inverse exclusive matrix of the Path.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The inverse of the matrix for all transforms in the Path excluding the end Node in the Path if it is Transform',
                                                                      'qualifiers': [],
                                                                      'type': 'MMatrix'},
                                                       'returnType': 'MMatrix',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                           'extendToShape': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nIf the object at the end of this path is a transform and there is a shape node directly beneath it in the hierarchy, then the path is extended to that geometry node.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                           'extendToShapeDirectlyBelow': [{'argInfo': {'index': {'doc': 'contains the index of the shape to extend the path to',
                                                                                 'type': 'uint'}},
                                                           'args': [('index',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method is used if the end of the path is a transform and there are shapes directly below the transform. The shape to extend to is set by passing in an appropriate index parameter.',
                                                           'inArgs': ['index'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'index': ['unsigned']},
                                                           'types': {'index': 'uint'}}],
                           'fullPathName': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn a string representing the full path from the root of the dag to this object.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The full path name',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                           'getAPathTo': [{'argInfo': {'node': {'doc': 'DAG Node for which Paths are determined ',
                                                                'type': 'MObject'},
                                                       'path': {'doc': 'reference to the path of the specified DAG Node',
                                                                'type': 'MDagPath'}},
                                           'args': [('node',
                                                     'MObject',
                                                     'in'),
                                                    ('path',
                                                     'MDagPath',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nDetermines the Path to the specified DAG Node. The Path returned is rooted at the World. If the object is instanced and has multiple paths, then the first one that is found is returned.',
                                           'inArgs': ['node'],
                                           'outArgs': ['path'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'node': ['const',
                                                                       '&'],
                                                              'path': ['&']},
                                           'types': {'node': 'MObject',
                                                     'path': 'MDagPath'}},
                                          {'argInfo': {'node': {'doc': 'DAG Node for which Paths are determined ',
                                                                'type': 'MObject'}},
                                           'args': [('node',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': '\r\nObsolete. \r\n',
                                           'inArgs': ['node'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Path to the specified Node',
                                                          'qualifiers': [],
                                                          'type': 'MDagPath'},
                                           'returnType': 'MDagPath',
                                           'static': True,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'node': ['const',
                                                                       '&']},
                                           'types': {'node': 'MObject'}}],
                           'getAllPathsBelow': [{'argInfo': {'pathArray': {'doc': 'Array containing all DAG Paths below this path excluding transforms.',
                                                                           'type': 'MDagPathArray'}},
                                                 'args': [('pathArray',
                                                           'MDagPathArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn all paths to leaf objects below this path excluding transforms.',
                                                 'inArgs': [],
                                                 'outArgs': ['pathArray'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'pathArray': ['&']},
                                                 'types': {'pathArray': 'MDagPathArray'}}],
                           'getAllPathsTo': [{'argInfo': {'node': {'doc': 'DAG Node for which Paths are determined ',
                                                                   'type': 'MObject'},
                                                          'pathArray': {'doc': 'Array containing all DAG Paths to the specified Node (implicit return)',
                                                                        'type': 'MDagPathArray'}},
                                              'args': [('node',
                                                        'MObject',
                                                        'in'),
                                                       ('pathArray',
                                                        'MDagPathArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines all Paths to the specified DAG Node.',
                                              'inArgs': ['node'],
                                              'outArgs': ['pathArray'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'node': ['const',
                                                                          '&'],
                                                                 'pathArray': ['&']},
                                              'types': {'node': 'MObject',
                                                        'pathArray': 'MDagPathArray'}}],
                           'getDrawOverrideInfo': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the draw override information for the given path. It will check from the bottom object of this path, then go upwards to find the first enabled draw override and record that information. If no enabled draw override is found, a default draw override information will be given with draw override disabled inside it.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'MDAGDrawOverrideInfo'},
                                                    'returnType': 'MDAGDrawOverrideInfo',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                           'getPath': [{'argInfo': {'i': {'doc': 'the index of the path to retrieve',
                                                          'type': 'uint'},
                                                    'path': {'doc': 'reference to the destination path ',
                                                             'type': 'MDagPath'}},
                                        'args': [('path',
                                                  'MDagPath',
                                                  'out'),
                                                 ('i', 'uint', 'in')],
                                        'defaults': {'i': 0},
                                        'deprecated': False,
                                        'doc': "\r\nReturn the i'th path. The zero'th path is the top-most path and must be rooted by the world. Additional paths are paths in the underworld of the object at the end of the previous path (path i-1).",
                                        'inArgs': ['i'],
                                        'outArgs': ['path'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'i': ['unsigned'],
                                                           'path': ['&']},
                                        'types': {'i': 'uint',
                                                  'path': 'MDagPath'}}],
                           'hasFn': [{'argInfo': {'type': {'doc': 'function set type to check ',
                                                           'type': ('MFn',
                                                                    'Type')}},
                                      'args': [('type',
                                                ('MFn', 'Type'),
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturns true if the object at the end of this DAG path supports the given function set.',
                                      'inArgs': ['type'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Boolean value indicating whether the function set is supported',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'type': []},
                                      'types': {'type': ('MFn', 'Type')}}],
                           'inclusiveMatrix': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines the inclusive matrix of the Path.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The matrix for all Transforms in the Path including the the end Node in the Path if it is a Transform',
                                                               'qualifiers': [],
                                                               'type': 'MMatrix'},
                                                'returnType': 'MMatrix',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                           'inclusiveMatrixInverse': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nDetermines the inverse inclusive matrix of the Path.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The inverse of the matrix for all Transforms in the Path including the end Node in the Path if it is a Transform',
                                                                      'qualifiers': [],
                                                                      'type': 'MMatrix'},
                                                       'returnType': 'MMatrix',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                           'instanceNumber': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFor an instanced object, this returns the instance number that this path represents in the DAG. The instance number can be used to determine which element of the world space array attributes of a DAG node to connect to get information regarding this instance.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The instance number represented by this path',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                           'isInstanced': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if the object at the end of the DAG path is instanced. It is instanced if there is more than one path to the node from the top of the DAG. Each instance of the node will be drawn separately in the view, but the geometry will be shared.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'True if the DAG node at the end of the path is instanced',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                           'isTemplated': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if the DAG Node at the end of the path is templated.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'True if the DAG node at the end of the path is templated',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                           'isValid': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nDetermines if Path is valid.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'True if valid',
                                                       'qualifiers': [],
                                                       'type': 'bool'},
                                        'returnType': 'bool',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                           'isVisible': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns true if the DAG Node at the end of the path is visible to the viewport. This method does not account for any viewport specific filtering.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'True if the DAG node at the end of the path is visible',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                           'length': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nDetermines the number of DAG Nodes in the Path not including the root.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Number of DAG Nodes not including the root',
                                                      'qualifiers': [],
                                                      'type': 'int'},
                                       'returnType': 'int',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                           'node': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nRetrieves the DAG Node for this DAG Path.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'DAG Node for this DAG Path',
                                                    'qualifiers': [],
                                                    'type': 'MObject'},
                                     'returnType': 'MObject',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}}],
                           'numberOfShapesDirectlyBelow': [{'argInfo': {'num': {'doc': 'on success, this parameter will be set to the number of shapes directly underneath the transform',
                                                                                'type': 'uint'}},
                                                            'args': [('num',
                                                                      'uint',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nIf the object at the end of this path is a transform, this method will return the number of shapes directly below the transform.',
                                                            'inArgs': [],
                                                            'outArgs': ['num'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'num': ['unsigned',
                                                                                       '&']},
                                                            'types': {'num': 'uint'}}],
                           'partialPathName': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn a string representing the partial path from the root of the dag to this object.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The partial path name',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                           'pathCount': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturn the number of paths which make up this path.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The path count',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                           'pop': [{'argInfo': {'num': {'doc': 'number of objects to pop off of the path',
                                                        'type': 'uint'}},
                                    'args': [('num', 'uint', 'in')],
                                    'defaults': {'num': 1},
                                    'deprecated': False,
                                    'doc': '\r\nPop the given number of objects off of the end of the path.',
                                    'inArgs': ['num'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {'num': ['unsigned']},
                                    'types': {'num': 'uint'}}],
                           'push': [{'argInfo': {'child': {'doc': 'child object to push onto the path',
                                                           'type': 'MObject'}},
                                     'args': [('child', 'MObject', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nPush an object onto the end of the path. The object must be a child of the object that is currently at the end of the path.',
                                     'inArgs': ['child'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'child': ['const',
                                                                  '&']},
                                     'types': {'child': 'MObject'}}],
                           'set': [{'argInfo': {'src': {'doc': 'DAG Path to be copied.',
                                                        'type': 'MDagPath'}},
                                    'args': [('src', 'MDagPath', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nSets this DAG Path equal to the specified DAG Path.',
                                    'inArgs': ['src'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {'src': ['const',
                                                               '&']},
                                    'types': {'src': 'MDagPath'}}],
                           'transform': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nRetrieves the lowest Transform in the DAG Path.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Lowest Transform for this DAG Path',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}]},
               'pymelEnums': {}},
  'MDagPathArray': {'enums': {},
                    'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                    ('setLength', 'length')],
                    'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'Zero-based index to the array',
                                                                       'type': 'uint'}},
                                                 'args': [('index',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nRetrieves the read-only DAG Path which is at the specified index in the array.',
                                                 'inArgs': ['index'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'DAG Path at the specified index ',
                                                                'qualifiers': ['&'],
                                                                'type': 'MDagPath'},
                                                 'returnType': 'MDagPath',
                                                 'static': False,
                                                 'typeQualifiers': {'index': ['unsigned']},
                                                 'types': {'index': 'uint'}},
                                                {'argInfo': {'index': {'doc': 'Zero-based index to the array',
                                                                       'type': 'uint'}},
                                                 'args': [('index',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nRetrieves the DAG Path which is at the specified index in the array.',
                                                 'inArgs': ['index'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'DAG Path at the specified index ',
                                                                'qualifiers': ['&'],
                                                                'type': 'MDagPath'},
                                                 'returnType': 'MDagPath',
                                                 'static': False,
                                                 'typeQualifiers': {'index': ['unsigned']},
                                                 'types': {'index': 'uint'}}],
                                'append': [{'argInfo': {'element': {'doc': 'DAG Path to be appended',
                                                                    'type': 'MDagPath'}},
                                            'args': [('element',
                                                      'MDagPath',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nAppends the given DAG Path to the end of the array.',
                                            'inArgs': ['element'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'element': ['const',
                                                                           '&']},
                                            'types': {'element': 'MDagPath'}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'clear': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nClears this array. Length of the array becomes zero.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                 'type': 'MDagPathArray'}},
                                          'args': [('source',
                                                    'MDagPathArray',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nCopy the contents of the source array to this array.',
                                          'inArgs': ['source'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'source': ['const',
                                                                        '&']},
                                          'types': {'source': 'MDagPathArray'}}],
                                'insert': [{'argInfo': {'element': {'doc': 'DAG Path to be inserted ',
                                                                    'type': 'MDagPath'},
                                                        'index': {'doc': 'Zero-based index to the array',
                                                                  'type': 'uint'}},
                                            'args': [('element',
                                                      'MDagPath',
                                                      'in'),
                                                     ('index',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nInserts the given DAG Path at the specified index in the array.',
                                            'inArgs': ['element',
                                                       'index'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'element': ['const',
                                                                           '&'],
                                                               'index': ['unsigned']},
                                            'types': {'element': 'MDagPath',
                                                      'index': 'uint'}}],
                                'length': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermines the number of elements in the array.',
                                            'inArgs': [],
                                            'inverse': ('setLength',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Number of elements in the array ',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                'remove': [{'argInfo': {'index': {'doc': 'Zero-based index to the array',
                                                                  'type': 'uint'}},
                                            'args': [('index',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nRemoves the DAG Path which is at the specified index in the array.',
                                            'inArgs': ['index'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'index': ['unsigned']},
                                            'types': {'index': 'uint'}}],
                                'set': [{'argInfo': {'element': {'doc': 'New DAG path to be set on the indicated element ',
                                                                 'type': 'MDagPath'},
                                                     'index': {'doc': 'Zero-based index to the array',
                                                               'type': 'uint'}},
                                         'args': [('element',
                                                   'MDagPath',
                                                   'in'),
                                                  ('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSets an element of the array to the given DAG path.',
                                         'inArgs': ['element', 'index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'element': ['const',
                                                                        '&'],
                                                            'index': ['unsigned']},
                                         'types': {'element': 'MDagPath',
                                                   'index': 'uint'}}],
                                'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                      'type': 'uint'}},
                                               'args': [('length',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                               'inArgs': ['length'],
                                               'inverse': ('length',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'length': ['unsigned']},
                                               'types': {'length': 'uint'}}],
                                'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                   'type': 'uint'}},
                                                      'args': [('newIncrement',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                      'inArgs': ['newIncrement'],
                                                      'inverse': ('sizeIncrement',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'newIncrement': ['unsigned']},
                                                      'types': {'newIncrement': 'uint'}}],
                                'sizeIncrement': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                   'inArgs': [],
                                                   'inverse': ('setSizeIncrement',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'length': 'getLength',
                                     'sizeIncrement': 'getSizeIncrement'}},
  'MDataBlock': {'enums': {},
                 'invertibles': [('setContext', 'context'),
                                 ('setClean', 'isClean')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'context': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns a copy of the dependecy graph context for which this data block was created. The context is used to specify how a dependency node is going to be evaluated.',
                                          'inArgs': [],
                                          'inverse': ('setContext',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The dependency graph context',
                                                         'qualifiers': [],
                                                         'type': 'MDGContext'},
                                          'returnType': 'MDGContext',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                             'inputArrayValue': [{'argInfo': {'plug': {'doc': 'the plug whose data you wish to access ',
                                                                       'type': 'MPlug'}},
                                                  'args': [('plug',
                                                            'MPlug',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets an array handle to this data block for the given plug's data. This is only valid if the given plug has array data. The data represented by the handle will be valid. If the data is from a dirty connection, then the connection will be evaluated. If no connection is present, then the value that the plug has been set to will be returned. If the plug has not been set to a particular value, then the default value will be returned.",
                                                  'inArgs': ['plug'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': "Array data handle for the given plug's data",
                                                                 'qualifiers': [],
                                                                 'type': 'MArrayDataHandle'},
                                                  'returnType': 'MArrayDataHandle',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'plug': ['const',
                                                                              '&']},
                                                  'types': {'plug': 'MPlug'}},
                                                 {'argInfo': {'attribute': {'doc': 'The attribute whose data you wish to access ',
                                                                            'type': 'MObject'}},
                                                  'args': [('attribute',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGets an array handle to this data block for the given attribute's data. This is only valid if the given attribute has array data. The data represented by the handle will be valid. If the data is from a dirty connection, then the connection will be evaluated. If no connection is present, then the value that the attribute has been set to will be returned. If the attribute has not been set to a particular value, then the default value will be returned.",
                                                  'inArgs': ['attribute'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': "Array data handle for the given attribute's data",
                                                                 'qualifiers': [],
                                                                 'type': 'MArrayDataHandle'},
                                                  'returnType': 'MArrayDataHandle',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'attribute': ['const',
                                                                                   '&']},
                                                  'types': {'attribute': 'MObject'}}],
                             'inputValue': [{'argInfo': {'plug': {'doc': 'the plug whose data you wish to access ',
                                                                  'type': 'MPlug'}},
                                             'args': [('plug',
                                                       'MPlug',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nGets a handle to this data block for the given plug's data. The data represented by the handle is guaranteed to be valid for reading. If the data is from a dirty connection, then the connection will be evaluated. If no connection is present, then the value that the plug has been set to will be returned. If the plug has not been set to a particular value, then the default value will be returned.",
                                             'inArgs': ['plug'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': "Data handle for the given plug's data",
                                                            'qualifiers': [],
                                                            'type': 'MDataHandle'},
                                             'returnType': 'MDataHandle',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'plug': ['const',
                                                                         '&']},
                                             'types': {'plug': 'MPlug'}},
                                            {'argInfo': {'attribute': {'doc': 'the attribute of the node that you want to access ',
                                                                       'type': 'MObject'}},
                                             'args': [('attribute',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nGets a handle to this data block for the given attribute's data. The data represented by the handle is guaranteed to be valid for reading. If the data is from a dirty connection, then the connection will be evaluated. If no connection is present, then the value that the attribute has been set to will be returned. If the attribute has not been set to a particular value, then the default value will be returned.",
                                             'inArgs': ['attribute'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': "Data handle for the given attribute's data",
                                                            'qualifiers': [],
                                                            'type': 'MDataHandle'},
                                             'returnType': 'MDataHandle',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'attribute': ['const',
                                                                              '&']},
                                             'types': {'attribute': 'MObject'}}],
                             'isClean': [{'argInfo': {'plug': {'doc': 'the plug that is to be query',
                                                               'type': 'MPlug'}},
                                          'args': [('plug',
                                                    'MPlug',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nQueries the dependency graph to see whether the given plug is clean.',
                                          'inArgs': ['plug'],
                                          'inverse': ('setClean', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Result boolean code, true if plug is clean, false otherwise. ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'plug': ['const',
                                                                      '&']},
                                          'types': {'plug': 'MPlug'}},
                                         {'argInfo': {'attribute': {'doc': 'The attribute to query. ',
                                                                    'type': 'MObject'}},
                                          'args': [('attribute',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nQueries the dependency graph to see whether the given attribute is clean.',
                                          'inArgs': ['attribute'],
                                          'inverse': ('setClean', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'true if the attribute is clean, false otherwise.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'attribute': ['const',
                                                                           '&']},
                                          'types': {'attribute': 'MObject'}}],
                             'outputArrayValue': [{'argInfo': {'plug': {'doc': 'the plug whose data you wish to access ',
                                                                        'type': 'MPlug'}},
                                                   'args': [('plug',
                                                             'MPlug',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGets a handle to this data block for the given plug. No dependency graph evaluations will be done, and therefore the data is not guaranteed to be valid (i.e. it may be dirty). Typically, this method is used to get the handle during compute in order to write output data to it.',
                                                   'inArgs': ['plug'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': "Array data handle for the given plug's data",
                                                                  'qualifiers': [],
                                                                  'type': 'MArrayDataHandle'},
                                                   'returnType': 'MArrayDataHandle',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'plug': ['const',
                                                                               '&']},
                                                   'types': {'plug': 'MPlug'}},
                                                  {'argInfo': {'attribute': {'doc': 'the attribute of the node that you want to access ',
                                                                             'type': 'MObject'}},
                                                   'args': [('attribute',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\r\nGets a handle to this data block for the given attribute's data. The data is not guaranteed to be valid. No dependency graph evaluations will be done. Therefore, this handle should be used only for writing.",
                                                   'inArgs': ['attribute'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': "Array data handle for the given attribute's data",
                                                                  'qualifiers': [],
                                                                  'type': 'MArrayDataHandle'},
                                                   'returnType': 'MArrayDataHandle',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'attribute': ['const',
                                                                                    '&']},
                                                   'types': {'attribute': 'MObject'}}],
                             'outputValue': [{'argInfo': {'plug': {'doc': 'the plug whose data you wish to access ',
                                                                   'type': 'MPlug'}},
                                              'args': [('plug',
                                                        'MPlug',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nGets a handle to this data block for the given plug's data. The data is not guaranteed to be valid. No dependency graph evaluations will be done. Therefore, this handle should be used only for writing.",
                                              'inArgs': ['plug'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': "Data handle for the given plug's data",
                                                             'qualifiers': [],
                                                             'type': 'MDataHandle'},
                                              'returnType': 'MDataHandle',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'plug': ['const',
                                                                          '&']},
                                              'types': {'plug': 'MPlug'}},
                                             {'argInfo': {'attribute': {'doc': 'the attribute of the node that you want to access ',
                                                                        'type': 'MObject'}},
                                              'args': [('attribute',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nGets a handle to this data block for the given attribute's data. The data is not guaranteed to be valid. No dependency graph evaluations will be done. Therefore, this handle should be used only for writing.",
                                              'inArgs': ['attribute'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': "Data handle for the given attribute's data",
                                                             'qualifiers': [],
                                                             'type': 'MDataHandle'},
                                              'returnType': 'MDataHandle',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'attribute': ['const',
                                                                               '&']},
                                              'types': {'attribute': 'MObject'}}],
                             'setClean': [{'argInfo': {'plug': {'doc': 'the plug that is to be marked clean',
                                                                'type': 'MPlug'}},
                                           'args': [('plug',
                                                     'MPlug',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nTells the dependency graph that the given plug has been updated and is now clean. This should be called after the data in the plug has been recalculated from the inputs of the node.',
                                           'inArgs': ['plug'],
                                           'inverse': ('isClean', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'plug': ['const',
                                                                       '&']},
                                           'types': {'plug': 'MPlug'}},
                                          {'argInfo': {'attribute': {'doc': 'the attribute that we have updated the data for',
                                                                     'type': 'MObject'}},
                                           'args': [('attribute',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nTells the dependency graph that the given attribute has been updated and is now clean. This should be called after the data in the plug has been recalculated from the inputs of the node.',
                                           'inArgs': ['attribute'],
                                           'inverse': ('isClean', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'attribute': ['const',
                                                                            '&']},
                                           'types': {'attribute': 'MObject'}}],
                             'setContext': [{'argInfo': {'ctx': {'doc': 'the dependency graph context',
                                                                 'type': 'MDGContext'}},
                                             'args': [('ctx',
                                                       'MDGContext',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the dependency graph context for this data block. The context is used to specify how a dependency node is going to be evaluated, thus replacing the context for the given datablock. This does not modify the dirty state of the datablock so that they apply to the new context.',
                                             'inArgs': ['ctx'],
                                             'inverse': ('context', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'ctx': ['const',
                                                                        '&']},
                                             'types': {'ctx': 'MDGContext'}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'context': 'getContext'}},
  'MDataHandle': {'enums': {},
                  'methods': {'acceptedTypeIds': [{'argInfo': {'typids': {'doc': 'an unsigned int array to copy the ids to',
                                                                          'type': 'MUintArray'}},
                                                   'args': [('typids',
                                                             'MUintArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method returns an array of  MTypeId  ids that the data handle can accept. The  MTypeId  can be reconstructed using the unsigned int in id.',
                                                   'inArgs': [],
                                                   'outArgs': ['typids'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'typids': ['&']},
                                                   'types': {'typids': 'MUintArray'}}],
                              'asAddr': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the data represented by this handle in the data block.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*&'],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asAngle': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the data represented by this handle in the data block.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MAngle'},
                                           'returnType': 'MAngle',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asBool': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the data represented by this handle in the data block.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "The handle's data as a boolean ",
                                                         'qualifiers': ['&'],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asChar': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the data represented by this handle in the data block.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['&'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asDistance': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the data represented by this handle in the data block.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MDistance'},
                                              'returnType': 'MDistance',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'asDouble': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The handle's data as a double ",
                                                           'qualifiers': ['&'],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asDouble2': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the data represented by this handle in the data block.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['&'],
                                                            'type': 'double2'},
                                             'returnType': 'double2',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asDouble3': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the data represented by this handle in the data block.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': "The handle's data as an array array of three doubles ",
                                                            'qualifiers': ['&'],
                                                            'type': 'double3'},
                                             'returnType': 'double3',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asFloat': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the data represented by this handle in the data block.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "The handle's data as a float ",
                                                          'qualifiers': ['&'],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asFloat2': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The handle's data as an array of two floats ",
                                                           'qualifiers': ['&'],
                                                           'type': 'float2'},
                                            'returnType': 'float2',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asFloat3': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The handle's data as an array of three float values ",
                                                           'qualifiers': ['&'],
                                                           'type': 'float3'},
                                            'returnType': 'float3',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asFloatMatrix': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the data represented by this handle in the data block. This method is only valid for attributes created using the  MFnMatrixAttribute  function set.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': "The handle's data as a matrix of floats ",
                                                                'qualifiers': ['&'],
                                                                'type': 'MFloatMatrix'},
                                                 'returnType': 'MFloatMatrix',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'asFloatVector': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the data represented by this handle in the data block.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': "The handle's data as a vector ",
                                                                'qualifiers': ['&'],
                                                                'type': 'MFloatVector'},
                                                 'returnType': 'MFloatVector',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'asGenericBool': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the generic data represented by this handle in the data block.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'asGenericChar': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the generic data represented by this handle in the data block.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'asGenericDouble': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the generic data represented by this handle in the data block.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'double'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                              'asGenericFloat': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the generic data represented by this handle in the data block.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'float'},
                                                  'returnType': 'float',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                              'asGenericInt': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the generic data represented by this handle in the data block.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'asGenericInt64': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the generic data represented by this handle in the data block.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MInt64'},
                                                  'returnType': 'MInt64',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                              'asGenericShort': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the generic data represented by this handle in the data block.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'short'},
                                                  'returnType': 'short',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                              'asInt': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the data represented by this handle in the data block.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': "The handle's data as a int integer ",
                                                        'qualifiers': ['&'],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'asInt2': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the data represented by this handle in the data block.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['&'],
                                                         'type': 'int2'},
                                          'returnType': 'int2',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asInt3': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the data represented by this handle in the data block.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['&'],
                                                         'type': 'int3'},
                                          'returnType': 'int3',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asInt64': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the data represented by this handle in the data block.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['&'],
                                                          'type': 'MInt64'},
                                           'returnType': 'MInt64',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asLong': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': True,
                                          'doc': '\n This method is obsolete. \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "The handle's data as a int integer ",
                                                         'qualifiers': ['&'],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asLong2': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': '\n This method is obsolete. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "The handle's data as an array of two int integers ",
                                                          'qualifiers': ['&'],
                                                          'type': 'long2'},
                                           'returnType': 'long2',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asLong3': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': '\n This method is obsolete. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "The handle's data as an array of three int integers ",
                                                          'qualifiers': ['&'],
                                                          'type': 'long3'},
                                           'returnType': 'long3',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asMatrix': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block. This method is only valid for attributes created using the  MFnMatrixAttribute  function set.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The handle's data as a matrix ",
                                                           'qualifiers': ['&'],
                                                           'type': 'MMatrix'},
                                            'returnType': 'MMatrix',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asMesh': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the mesh function set and iterators. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "The handle's data as a mesh (polygonal surface) ",
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asMeshTransformed': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the mesh function set ( MFnMesh ) or any of the mesh iterators.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                              'asNurbsCurve': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs curve function set and iterator. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': "The handle's data as a nurbs curve ",
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'asNurbsCurveTransformed': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs curve function set ( MFnNurbsCurve ) or the nurbs curve CV iterator ( MItCurveCV ).',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': "The handle's data as a nurbs curve ",
                                                                          'qualifiers': [],
                                                                          'type': 'MObject'},
                                                           'returnType': 'MObject',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                              'asNurbsSurface': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs surface function set and iterator. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': "The handle's data as a nurbs surface ",
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                              'asNurbsSurfaceTransformed': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs surface function set ( MFnNurbsSurface ) or the nurbs surface CV iterator ( MItSurfaceCV ).',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': 'MObject'},
                                                             'returnType': 'MObject',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                              'asPluginData': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the data represented by this handle in the data block. The object is returned as plugin data. This should be used to access data types defined by plugins.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': "The handle's data ",
                                                               'qualifiers': ['*'],
                                                               'type': 'MPxData'},
                                                'returnType': 'MPxData',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'asShort': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the data represented by this handle in the data block.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "The handle's data as a short integer ",
                                                          'qualifiers': ['&'],
                                                          'type': 'short'},
                                           'returnType': 'short',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asShort2': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['&'],
                                                           'type': 'short2'},
                                            'returnType': 'short2',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asShort3': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['&'],
                                                           'type': 'short3'},
                                            'returnType': 'short3',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asString': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The handle's data as a string ",
                                                           'qualifiers': ['&'],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asSubdSurface': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the subdivision surface function set and iterator. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': "The handle's data as a subdivision surface ",
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'asSubdSurfaceTransformed': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns the data represented by this handle in the data block. The object returned by this call may be used directly with the subdivision surface function set (MFnSubdSurface) or the subdivision surface iterators ( MItSubdVertex ,  MItSubdFace ,  MItSubdEdge ).',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'MObject'},
                                                            'returnType': 'MObject',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                              'asTime': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the data represented by this handle in the data block. Even though this method does not return a reference to an  MTime , modifications to the  MTime  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "The handle's data as an MTime ",
                                                         'qualifiers': [],
                                                         'type': 'MTime'},
                                          'returnType': 'MTime',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asUChar': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the data represented by this handle in the data block.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['&'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asVector': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the data represented by this handle in the data block.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The handle's data as a vector ",
                                                           'qualifiers': ['&'],
                                                           'type': 'MVector'},
                                            'returnType': 'MVector',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'child': [{'argInfo': {'plug': {'doc': 'the plug of the child',
                                                              'type': 'MPlug'}},
                                         'args': [('plug',
                                                   'MPlug',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nGet a handle to a child of this handle. This is used if you have a handle to a compound attribute.',
                                         'inArgs': ['plug'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The data handle for the child ',
                                                        'qualifiers': [],
                                                        'type': 'MDataHandle'},
                                         'returnType': 'MDataHandle',
                                         'static': False,
                                         'typeQualifiers': {'plug': ['const',
                                                                     '&']},
                                         'types': {'plug': 'MPlug'}},
                                        {'argInfo': {'attribute': {'doc': 'the attribute of the child',
                                                                   'type': 'MObject'}},
                                         'args': [('attribute',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nGet a handle to a child of this handle. This is used if you have a handle to a compound attribute.',
                                         'inArgs': ['attribute'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The data handle for the child ',
                                                        'qualifiers': [],
                                                        'type': 'MDataHandle'},
                                         'returnType': 'MDataHandle',
                                         'static': False,
                                         'typeQualifiers': {'attribute': ['const',
                                                                          '&']},
                                         'types': {'attribute': 'MObject'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'copy': [{'argInfo': {'src': {'doc': 'the handle to the attribute to copy',
                                                            'type': 'MDataHandle'}},
                                        'args': [('src',
                                                  'MDataHandle',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopies the attribute from the  src  attribute to the attribute referenced by this handle. This is the only method which can completely copy a compound attribute from one handle to another. The construct outputHandle.set (inputHandle.data()) will not work for compound or multi attributes.',
                                        'inArgs': ['src'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'src': ['const',
                                                                   '&']},
                                        'types': {'src': 'MDataHandle'}}],
                              'copyWritable': [{'argInfo': {'src': {'doc': 'the handle to the attribute to copy',
                                                                    'type': 'MDataHandle'}},
                                                'args': [('src',
                                                          'MDataHandle',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCopies the attribute from the  src  attribute to the attribute referenced by this handle. When the copy is made it ensures that the data in this handle is writable. That is, if the src handle has a writable copy of the data then it will be duplicated, otherwise this handle will claim the writer status for the data.',
                                                'inArgs': ['src'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'src': ['const',
                                                                           '&']},
                                                'types': {'src': 'MDataHandle'}}],
                              'data': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the data object from this handle. The object returned should be used with the appropriate data function set. This method is not valid for simple numeric types.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The data object ',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'datablock': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the datablock associated with this data handle.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The MDatablock representing the datablock associated with this data handle.',
                                                            'qualifiers': [],
                                                            'type': 'MDataBlock'},
                                             'returnType': 'MDataBlock',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                              'geometryTransformMatrix': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method returns a reference to the local-to-world transformation matrix that can accompany a geometry data object. Only use this method on handles to geometry data (curves, surfaces, and meshes).',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['&'],
                                                                          'type': 'MMatrix'},
                                                           'returnType': 'MMatrix',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                              'isGeneric': [{'argInfo': {'isNull': {'doc': 'returns true if this handle is not set',
                                                                    'type': 'bool'},
                                                         'isNumeric': {'doc': 'returns true if this handle is for simple generic numeric data ',
                                                                       'type': 'bool'}},
                                             'args': [('isNumeric',
                                                       'bool',
                                                       'out'),
                                                      ('isNull',
                                                       'bool',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns true if this handle is for generic data. There are 2 forms of generic data. The first is for simple data and is used if the isNumeric parameter returns true. In this case, the asGeneric*() and setGeneric*() methods of this class are used to query and set values. The second form of generic data is for more complex attribute types. As a result the type of the object must be checked and an appropriate attribute function set initialized with the object.',
                                             'inArgs': [],
                                             'outArgs': ['isNumeric',
                                                         'isNull'],
                                             'returnInfo': {'doc': 'True will be returned if this handle points to a generic attribute ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'isNull': ['&'],
                                                                'isNumeric': ['&']},
                                             'types': {'isNull': 'bool',
                                                       'isNumeric': 'bool'}}],
                              'isNumeric': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns true if this handle is for simple numeric data. That means that the numeric data is directly accessible through the non-generic as*() and set*() methods of this handle. For example, depending on handle initialization, the  asBool()  may be called but the  asGenericBool()  should not be called.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'numericType': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the type of data represented by this handle. This method is only valid for data handles of simple numeric types.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFnNumericData',
                                                                       'Type')},
                                               'returnType': ('MFnNumericData',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'set2Double': [{'argInfo': {'val1': {'doc': 'the first value in the two element array ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'the second value in the two element array ',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'in'),
                                                       ('val2',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the data that this handle represents in the data block.',
                                              'inArgs': ['val1', 'val2'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': []},
                                              'types': {'val1': 'double',
                                                        'val2': 'double'}}],
                              'set2Float': [{'argInfo': {'val1': {'doc': 'the first value in the two element array ',
                                                                  'type': 'float'},
                                                         'val2': {'doc': 'the second value in the two element array ',
                                                                  'type': 'float'}},
                                             'args': [('val1',
                                                       'float',
                                                       'in'),
                                                      ('val2',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the data that this handle represents in the data block.',
                                             'inArgs': ['val1', 'val2'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'val1': [],
                                                                'val2': []},
                                             'types': {'val1': 'float',
                                                       'val2': 'float'}}],
                              'set2Int': [{'argInfo': {'val1': {'doc': 'the first value in the two element array ',
                                                                'type': 'int'},
                                                       'val2': {'doc': 'the second value in the two element array ',
                                                                'type': 'int'}},
                                           'args': [('val1',
                                                     'int',
                                                     'in'),
                                                    ('val2',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSet the data that this handle represents in the data block.',
                                           'inArgs': ['val1', 'val2'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'val1': [],
                                                              'val2': []},
                                           'types': {'val1': 'int',
                                                     'val2': 'int'}}],
                              'set2Short': [{'argInfo': {'val1': {'doc': 'the first value in the two element array ',
                                                                  'type': 'short'},
                                                         'val2': {'doc': 'the second value in the two element array ',
                                                                  'type': 'short'}},
                                             'args': [('val1',
                                                       'short',
                                                       'in'),
                                                      ('val2',
                                                       'short',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the data that this handle represents in the data block.',
                                             'inArgs': ['val1', 'val2'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'val1': [],
                                                                'val2': []},
                                             'types': {'val1': 'short',
                                                       'val2': 'short'}}],
                              'set3Double': [{'argInfo': {'val1': {'doc': 'the first value in the three element array ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'the second value in the three element array ',
                                                                   'type': 'double'},
                                                          'val3': {'doc': 'the third value in the three element array ',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'in'),
                                                       ('val2',
                                                        'double',
                                                        'in'),
                                                       ('val3',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the data that this handle represents in the data block.',
                                              'inArgs': ['val1',
                                                         'val2',
                                                         'val3'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': [],
                                                                 'val3': []},
                                              'types': {'val1': 'double',
                                                        'val2': 'double',
                                                        'val3': 'double'}}],
                              'set3Float': [{'argInfo': {'val1': {'doc': 'the first value in the three element array ',
                                                                  'type': 'float'},
                                                         'val2': {'doc': 'the second value in the three element array ',
                                                                  'type': 'float'},
                                                         'val3': {'doc': 'the third value in the three element array ',
                                                                  'type': 'float'}},
                                             'args': [('val1',
                                                       'float',
                                                       'in'),
                                                      ('val2',
                                                       'float',
                                                       'in'),
                                                      ('val3',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the data that this handle represents in the data block.',
                                             'inArgs': ['val1',
                                                        'val2',
                                                        'val3'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'val1': [],
                                                                'val2': [],
                                                                'val3': []},
                                             'types': {'val1': 'float',
                                                       'val2': 'float',
                                                       'val3': 'float'}}],
                              'set3Int': [{'argInfo': {'val1': {'doc': 'the first value in the three element array ',
                                                                'type': 'int'},
                                                       'val2': {'doc': 'the second value in the three element array ',
                                                                'type': 'int'},
                                                       'val3': {'doc': 'the third value in the three element array ',
                                                                'type': 'int'}},
                                           'args': [('val1',
                                                     'int',
                                                     'in'),
                                                    ('val2',
                                                     'int',
                                                     'in'),
                                                    ('val3',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSet the data that this handle represents in the data block.',
                                           'inArgs': ['val1',
                                                      'val2',
                                                      'val3'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'val1': [],
                                                              'val2': [],
                                                              'val3': []},
                                           'types': {'val1': 'int',
                                                     'val2': 'int',
                                                     'val3': 'int'}}],
                              'set3Short': [{'argInfo': {'val1': {'doc': 'the first value in the three element array ',
                                                                  'type': 'short'},
                                                         'val2': {'doc': 'the second value in the three element array ',
                                                                  'type': 'short'},
                                                         'val3': {'doc': 'the third value in the three element array ',
                                                                  'type': 'short'}},
                                             'args': [('val1',
                                                       'short',
                                                       'in'),
                                                      ('val2',
                                                       'short',
                                                       'in'),
                                                      ('val3',
                                                       'short',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the data that this handle represents in the data block.',
                                             'inArgs': ['val1',
                                                        'val2',
                                                        'val3'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'val1': [],
                                                                'val2': [],
                                                                'val3': []},
                                             'types': {'val1': 'short',
                                                       'val2': 'short',
                                                       'val3': 'short'}}],
                              'setBool': [{'argInfo': {'val': {'doc': 'the new value ',
                                                               'type': 'bool'}},
                                           'args': [('val',
                                                     'bool',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSet the data that this handle represents in the data block.',
                                           'inArgs': ['val'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'val': []},
                                           'types': {'val': 'bool'}}],
                              'setChar': [{'argInfo': {'val': {'doc': 'the new value ',
                                                               'type': 'char'}},
                                           'args': [('val',
                                                     'char',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSet the data that this handle represents in the data block.',
                                           'inArgs': ['val'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'val': []},
                                           'types': {'val': 'char'}}],
                              'setClean': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nMarks the data that is represented by this handle as being clean. This should be done after recalculating the data from the inputs.  MDataHandle::setClean()  does not clean the children of array attributes. For example, it cannot clean myNode.output[0].outputAttrX. One workaround is to call  MDataBlock::setClean()  to clean the datablock using the plug of outputAttrX. \r\n  Reprocessed example  \n Examples: \n \n   \n anisotropicShader.cpp ,  apiMeshShape.cpp ,  backfillShader.cpp ,  blindDataShader.cpp ,  buildRotationNode.cpp ,  cellShader.cpp ,  cgfxShaderNode.cpp ,  checkerShader.cpp ,  clearcoat.cpp ,  compositingShader.cpp ,  contrastShader.cpp ,  cvColorShader.cpp ,  displacementShader.cpp ,  flameShader.cpp ,  gammaShader.cpp ,  genericAttributeNode.cpp ,  geomShader.cpp ,  hwDecalBumpShader_NV20.cpp ,  hwPhongShader.cpp ,  hwReflectBumpShader_NV20.cpp ,  hwRefractReflectShader_NV20.cpp ,  hwToonShader_NV20.cpp ,  hwUnlitShader.cpp ,  interpShader.cpp ,  lambertShader.cpp ,  lavaShader.cpp ,  lightShader.cpp ,  meshOpNode.cpp ,  mixtureShader.cpp ,  noiseShader.cpp ,  phongShader.cpp ,  renderAccessNode.cpp ,  rockingTransform.cpp ,  shadowMatteShader.cpp ,  shiftNode.cpp ,  slopeShaderNode.cpp ,  solidCheckerShader.cpp ,  splitUVNode.cpp , and  volumeShader.cpp . \n \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'setDouble': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                 'type': 'double'}},
                                             'args': [('val',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the data that this handle represents in the data block.',
                                             'inArgs': ['val'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'val': []},
                                             'types': {'val': 'double'}}],
                              'setFloat': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                'type': 'float'}},
                                            'args': [('val',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the data that this handle represents in the data block.',
                                            'inArgs': ['val'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'val': []},
                                            'types': {'val': 'float'}}],
                              'setGenericBool': [{'argInfo': {'force': {'doc': 'force the new type of the attribute to be bool ',
                                                                        'type': 'bool'},
                                                              'value': {'doc': 'the new bool value ',
                                                                        'type': 'bool'}},
                                                  'args': [('value',
                                                            'bool',
                                                            'in'),
                                                           ('force',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the data that this handle represents in the data block.',
                                                  'inArgs': ['value',
                                                             'force'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'force': [],
                                                                     'value': []},
                                                  'types': {'force': 'bool',
                                                            'value': 'bool'}}],
                              'setGenericChar': [{'argInfo': {'force': {'doc': 'force the new type of the attribute to be char ',
                                                                        'type': 'bool'},
                                                              'value': {'doc': 'the new char value ',
                                                                        'type': 'uchar'}},
                                                  'args': [('value',
                                                            'uchar',
                                                            'in'),
                                                           ('force',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the data that this handle represents in the data block.',
                                                  'inArgs': ['value',
                                                             'force'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'force': [],
                                                                     'value': ['unsigned']},
                                                  'types': {'force': 'bool',
                                                            'value': 'uchar'}}],
                              'setGenericDouble': [{'argInfo': {'force': {'doc': 'force the new type of the attribute to be double ',
                                                                          'type': 'bool'},
                                                                'value': {'doc': 'the new double value ',
                                                                          'type': 'double'}},
                                                    'args': [('value',
                                                              'double',
                                                              'in'),
                                                             ('force',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the data that this handle represents in the data block.',
                                                    'inArgs': ['value',
                                                               'force'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'force': [],
                                                                       'value': []},
                                                    'types': {'force': 'bool',
                                                              'value': 'double'}}],
                              'setGenericFloat': [{'argInfo': {'force': {'doc': 'force the new type of the attribute to be float ',
                                                                         'type': 'bool'},
                                                               'value': {'doc': 'the new float value ',
                                                                         'type': 'float'}},
                                                   'args': [('value',
                                                             'float',
                                                             'in'),
                                                            ('force',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the data that this handle represents in the data block.',
                                                   'inArgs': ['value',
                                                              'force'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'force': [],
                                                                      'value': []},
                                                   'types': {'force': 'bool',
                                                             'value': 'float'}}],
                              'setGenericInt': [{'argInfo': {'force': {'doc': 'force the new type of the attribute to be int ',
                                                                       'type': 'bool'},
                                                             'value': {'doc': 'the new int value ',
                                                                       'type': 'int'}},
                                                 'args': [('value',
                                                           'int',
                                                           'in'),
                                                          ('force',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet the data that this handle represents in the data block.',
                                                 'inArgs': ['value',
                                                            'force'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'force': [],
                                                                    'value': []},
                                                 'types': {'force': 'bool',
                                                           'value': 'int'}}],
                              'setGenericInt64': [{'argInfo': {'force': {'doc': 'force the new type of the attribute to be 64-bit int ',
                                                                         'type': 'bool'},
                                                               'value': {'doc': 'the new 64-bit int value ',
                                                                         'type': 'MInt64'}},
                                                   'args': [('value',
                                                             'MInt64',
                                                             'in'),
                                                            ('force',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the data that this handle represents in the data block.',
                                                   'inArgs': ['value',
                                                              'force'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'force': [],
                                                                      'value': []},
                                                   'types': {'force': 'bool',
                                                             'value': 'MInt64'}}],
                              'setGenericShort': [{'argInfo': {'force': {'doc': 'force the new type of the attribute to be short ',
                                                                         'type': 'bool'},
                                                               'value': {'doc': 'the new short value ',
                                                                         'type': 'short'}},
                                                   'args': [('value',
                                                             'short',
                                                             'in'),
                                                            ('force',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the data that this handle represents in the data block.',
                                                   'inArgs': ['value',
                                                              'force'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'force': [],
                                                                      'value': []},
                                                   'types': {'force': 'bool',
                                                             'value': 'short'}}],
                              'setInt': [{'argInfo': {'val': {'doc': 'the new value ',
                                                              'type': 'int'}},
                                          'args': [('val', 'int', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nSet the data that this handle represents in the data block.',
                                          'inArgs': ['val'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'val': []},
                                          'types': {'val': 'int'}}],
                              'setInt64': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                'type': 'MInt64'}},
                                            'args': [('val',
                                                      'MInt64',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the data that this handle represents in the data block.',
                                            'inArgs': ['val'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'val': []},
                                            'types': {'val': 'MInt64'}}],
                              'setMAngle': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                 'type': 'MAngle'}},
                                             'args': [('val',
                                                       'MAngle',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the data that this handle represents in the data block.',
                                             'inArgs': ['val'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'val': ['const',
                                                                        '&']},
                                             'types': {'val': 'MAngle'}}],
                              'setMDistance': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                    'type': 'MDistance'}},
                                                'args': [('val',
                                                          'MDistance',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet the data that this handle represents in the data block.',
                                                'inArgs': ['val'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'val': ['const',
                                                                           '&']},
                                                'types': {'val': 'MDistance'}}],
                              'setMFloatMatrix': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                       'type': 'MFloatMatrix'}},
                                                   'args': [('val',
                                                             'MFloatMatrix',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the data that this handle represents in the data block.',
                                                   'inArgs': ['val'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'val': ['const',
                                                                              '&']},
                                                   'types': {'val': 'MFloatMatrix'}}],
                              'setMFloatVector': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                       'type': 'MFloatVector'}},
                                                   'args': [('val',
                                                             'MFloatVector',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the data that this handle represents in the data block.',
                                                   'inArgs': ['val'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'val': ['const',
                                                                              '&']},
                                                   'types': {'val': 'MFloatVector'}}],
                              'setMMatrix': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                  'type': 'MMatrix'}},
                                              'args': [('val',
                                                        'MMatrix',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the data that this handle represents in the data block. This method is only valid for attributes created using the  MFnMatrixAttribute  function set.',
                                              'inArgs': ['val'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val': ['const',
                                                                         '&']},
                                              'types': {'val': 'MMatrix'}}],
                              'setMObject': [{'argInfo': {'data': {'doc': 'the data object',
                                                                   'type': 'MObject'}},
                                              'args': [('data',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the data that this handle represents in the data block. This method assumes that the  MObject  is a dependency graph data object. These objects can be created using the appropriate  MFn ..Data function set. Note that this method cannot be used to copy compound or multi attributes from one handle to another via the construct outputHandle.set (inputHandle.data()). To copy these user defined attributes, the method  MDataHandle::copy  must be used.',
                                              'inArgs': ['data'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'data': ['const',
                                                                          '&']},
                                              'types': {'data': 'MObject'}}],
                              'setMPxData': [{'argInfo': {'data': {'doc': 'the data object',
                                                                   'type': 'MPxData'}},
                                              'args': [('data',
                                                        'MPxData',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the data that this handle represents in the data block. This method takes a pointer to a user defined data object. The data block will become the new owner of the data object that you pass in. Do not delete it.',
                                              'inArgs': ['data'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'data': ['*']},
                                              'types': {'data': 'MPxData'}}],
                              'setMTime': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                'type': 'MTime'}},
                                            'args': [('val',
                                                      'MTime',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the data that this handle represents in the data block.',
                                            'inArgs': ['val'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'val': ['const',
                                                                       '&']},
                                            'types': {'val': 'MTime'}}],
                              'setMVector': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                  'type': 'MVector'}},
                                              'args': [('val',
                                                        'MVector',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the data that this handle represents in the data block.',
                                              'inArgs': ['val'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val': ['const',
                                                                         '&']},
                                              'types': {'val': 'MVector'}}],
                              'setShort': [{'argInfo': {'val': {'doc': 'the new value ',
                                                                'type': 'short'}},
                                            'args': [('val',
                                                      'short',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the data that this handle represents in the data block.',
                                            'inArgs': ['val'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'val': []},
                                            'types': {'val': 'short'}}],
                              'setString': [{'argInfo': {'val': {'doc': 'the new string value ',
                                                                 'type': 'MString'}},
                                             'args': [('val',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the data that this handle represents in the data block.',
                                             'inArgs': ['val'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'val': ['const',
                                                                        '&']},
                                             'types': {'val': 'MString'}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the type of data represented by this handle.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MFnData',
                                                                'Type')},
                                        'returnType': ('MFnData', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'typeId': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the type of data represented by this handle as a type id. A type id is a four character code that is used to identify the data type. If no data exists for this handle, the type id will be 0x0.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'MTypeId'},
                                          'returnType': 'MTypeId',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                  'pymelEnums': {}},
  'MDeviceChannel': {'enums': {},
                     'methods': {'axisIndex': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the device state index corresponding to this device channel.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'childByIndex': [{'argInfo': {'index': {'doc': '',
                                                                         'type': 'int'}},
                                                   'args': [('index',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the specified child of this channel.',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MDeviceChannel'},
                                                   'returnType': 'MDeviceChannel',
                                                   'static': False,
                                                   'typeQualifiers': {'index': []},
                                                   'types': {'index': 'int'}}],
                                 'hasChildren': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermine whether this channel has children.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                 'longName': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the long name of the channel.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'name': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the short name of the channel.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                 'numChildren': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the number of children of this channel.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                 'parent': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the parent of this channel.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'MDeviceChannel'},
                                             'returnType': 'MDeviceChannel',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                     'pymelEnums': {}},
  'MDeviceState': {'enums': {},
                   'invertibles': [('setButtonState', 'buttonState'),
                                   ('setDevicePosition', 'devicePosition')],
                   'methods': {'buttonState': [{'argInfo': {'button': {'doc': 'The number of the button to be tested',
                                                                       'type': 'short'}},
                                                'args': [('button',
                                                          'short',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the state of the given button.',
                                                'inArgs': ['button'],
                                                'inverse': ('setButtonState',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' true button pressed  false button released   ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'button': ['const',
                                                                              'unsigned',
                                                                              'int']},
                                                'types': {'button': 'short'}},
                                               {'argInfo': {'buttonName': {'doc': 'The name of the button to be tested',
                                                                           'type': 'MString'}},
                                                'args': [('buttonName',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the state of the named button.',
                                                'inArgs': ['buttonName'],
                                                'inverse': ('setButtonState',
                                                            False),
                                                'outArgs': [],
                                                'pymelName': 'getButtonState',
                                                'returnInfo': {'doc': ' true button pressed  false button released   ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'buttonName': ['const',
                                                                                  '&']},
                                                'types': {'buttonName': 'MString'}}],
                               'devicePosition': [{'argInfo': {'axis': {'doc': 'The device axis to be tested',
                                                                        'type': 'short'}},
                                                   'args': [('axis',
                                                             'short',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the position of the device for the specified axis.',
                                                   'inArgs': ['axis'],
                                                   'inverse': ('setDevicePosition',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The position of the device for the specified axis ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'axis': ['const',
                                                                               'unsigned',
                                                                               'int']},
                                                   'types': {'axis': 'short'}},
                                                  {'argInfo': {'axisName': {'doc': 'The name of the device axis to be tested',
                                                                            'type': 'MString'}},
                                                   'args': [('axisName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the position of the device for the specified axis.',
                                                   'inArgs': ['axisName'],
                                                   'inverse': ('setDevicePosition',
                                                               False),
                                                   'outArgs': [],
                                                   'pymelName': 'getDevicePosition',
                                                   'returnInfo': {'doc': 'The position of the device for the specified axis ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'axisName': ['const',
                                                                                   '&']},
                                                   'types': {'axisName': 'MString'}}],
                               'isNull': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns  true  if this device state is NULL;',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': ' true The device state is NULL  false The device state is not NULL   ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'maxAxis': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the value of the axis with the largest value. This is used to dejitter absolute devices.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                               'setButtonState': [{'argInfo': {'button': {'doc': 'The button number ',
                                                                          'type': 'short'},
                                                               'state': {'doc': 'The state to be set (true or false) ',
                                                                         'type': 'bool'}},
                                                   'args': [('state',
                                                             'bool',
                                                             'in'),
                                                            ('button',
                                                             'short',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the state of the specified button.',
                                                   'inArgs': ['state',
                                                              'button'],
                                                   'inverse': ('buttonState',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'button': ['const',
                                                                                 'unsigned',
                                                                                 'int'],
                                                                      'state': ['const']},
                                                   'types': {'button': 'short',
                                                             'state': 'bool'}},
                                                  {'argInfo': {'buttonName': {'doc': 'The name of the button to be set ',
                                                                              'type': 'MString'},
                                                               'state': {'doc': 'The state to be set (true or false) ',
                                                                         'type': 'bool'}},
                                                   'args': [('state',
                                                             'bool',
                                                             'in'),
                                                            ('buttonName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the state of the specified button.',
                                                   'inArgs': ['state',
                                                              'buttonName'],
                                                   'inverse': ('buttonState',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'buttonName': ['const',
                                                                                     '&'],
                                                                      'state': ['const']},
                                                   'types': {'buttonName': 'MString',
                                                             'state': 'bool'}}],
                               'setDevicePosition': [{'argInfo': {'axis': {'doc': 'The axis of the device to be set ',
                                                                           'type': 'short'},
                                                                  'position': {'doc': 'The new position value ',
                                                                               'type': 'int'}},
                                                      'args': [('position',
                                                                'int',
                                                                'in'),
                                                               ('axis',
                                                                'short',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the position of the device for the specified axis.',
                                                      'inArgs': ['position',
                                                                 'axis'],
                                                      'inverse': ('devicePosition',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'axis': ['const',
                                                                                  'unsigned',
                                                                                  'int'],
                                                                         'position': ['const']},
                                                      'types': {'axis': 'short',
                                                                'position': 'int'}},
                                                     {'argInfo': {'axis': {'doc': 'The name of the axis of the device to be set ',
                                                                           'type': 'MString'},
                                                                  'position': {'doc': 'The new position value ',
                                                                               'type': 'int'}},
                                                      'args': [('position',
                                                                'int',
                                                                'in'),
                                                               ('axis',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the position of the device for the specified axis.',
                                                      'inArgs': ['position',
                                                                 'axis'],
                                                      'inverse': ('devicePosition',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'axis': ['const',
                                                                                  '&'],
                                                                         'position': ['const']},
                                                      'types': {'axis': 'MString',
                                                                'position': 'int'}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'buttonState': 'getButtonState',
                                    'devicePosition': 'getDevicePosition'}},
  'MDistance': {'enums': {'Unit': {'valueDocs': {'centimeters': 'Centimeters.',
                                                 'feet': 'Feet.',
                                                 'inches': 'Inches.',
                                                 'kCentimeters': 'Centimeters.',
                                                 'kFeet': 'Feet.',
                                                 'kInches': 'Inches.',
                                                 'kKilometers': 'Kilometers.',
                                                 'kMeters': 'Meters.',
                                                 'kMiles': 'Miles.',
                                                 'kMillimeters': 'Millimeters.',
                                                 'kYards': 'Yards.',
                                                 'kilometers': 'Kilometers.',
                                                 'meters': 'Meters.',
                                                 'miles': 'Miles.',
                                                 'millimeters': 'Millimeters.',
                                                 'yards': 'Yards.'},
                                   'values': "Enum('Unit', {'kInches': 1, 'kFeet': 2, 'kYards': 3, 'kMiles': 4, 'kMillimeters': 5, 'kCentimeters': 6, 'kKilometers': 7, 'kMeters': 8})"}},
                'invertibles': [('setValue', 'value'),
                                ('setInternalUnit', 'internalUnit'),
                                ('setUnit', 'unit')],
                'methods': {'as': [{'argInfo': {'otherUnit': {'doc': 'an element of the MDistance::Unit enum specifying the desired units ',
                                                              'type': ('MDistance',
                                                                       'Unit')}},
                                    'args': [('otherUnit',
                                              ('MDistance', 'Unit'),
                                              'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nReturn the current value of this instance in the provided units.',
                                    'inArgs': ['otherUnit'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'The current value in the given units',
                                                   'qualifiers': [],
                                                   'type': 'double'},
                                    'returnType': 'double',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                       'otherUnit': []},
                                    'types': {'otherUnit': ('MDistance',
                                                            'Unit')}}],
                            'asCentimeters': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the current value of this instance in centimeters.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The current value in the centimeters ',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                            'asFeet': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturn the current value of this instance in feet.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                            'asInches': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturn the current value of this instance in inches.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                            'asKilometers': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the current value of this instance in kilometers.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'double'},
                                              'returnType': 'double',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                            'asMeters': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturn the current value of this instance in meters.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                            'asMiles': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the current value of this instance in miles.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                            'asMillimeters': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the current value of this instance in millimeters.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                            'asUnits': [{'argInfo': {'otherUnit': {'doc': 'an element of the MDistance::Unit enum specifying the desired units ',
                                                                   'type': ('MDistance',
                                                                            'Unit')}},
                                         'args': [('otherUnit',
                                                   ('MDistance',
                                                    'Unit'),
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the current value of this instance in the provided units.',
                                         'inArgs': ['otherUnit'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The current value in the given units',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'otherUnit': []},
                                         'types': {'otherUnit': ('MDistance',
                                                                 'Unit')}}],
                            'asYards': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the current value of this instance in yards.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'internalToUI': [{'argInfo': {'internalValue': {'doc': 'a value in internal units',
                                                                            'type': 'double'}},
                                              'args': [('internalValue',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nConverts a value from internal units to UI units.',
                                              'inArgs': ['internalValue'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value in UI units ',
                                                             'qualifiers': [],
                                                             'type': 'double'},
                                              'returnType': 'double',
                                              'static': True,
                                              'typeQualifiers': {'internalValue': []},
                                              'types': {'internalValue': 'double'}}],
                            'internalUnit': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the internal unit system.',
                                              'inArgs': [],
                                              'inverse': ('setInternalUnit',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The internal unit for distance ',
                                                             'qualifiers': [],
                                                             'type': ('MDistance',
                                                                      'Unit')},
                                              'returnType': ('MDistance',
                                                             'Unit'),
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                            'setInternalUnit': [{'argInfo': {'internalUnit': {'doc': 'the internal unit to be used by distance',
                                                                              'type': ('MDistance',
                                                                                       'Unit')}},
                                                 'args': [('internalUnit',
                                                           ('MDistance',
                                                            'Unit'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': True,
                                                 'doc': '\n This method is obsolete. \n',
                                                 'inArgs': ['internalUnit'],
                                                 'inverse': ('internalUnit',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {'internalUnit': []},
                                                 'types': {'internalUnit': ('MDistance',
                                                                            'Unit')}}],
                            'setUIUnit': [{'argInfo': {'newUnit': {'doc': 'and element of the MDistance::Unit enum.',
                                                                   'type': ('MDistance',
                                                                            'Unit')}},
                                           'args': [('newUnit',
                                                     ('MDistance',
                                                      'Unit'),
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSet the unit system to be used by the user in the UI.',
                                           'inArgs': ['newUnit'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'newUnit': []},
                                           'types': {'newUnit': ('MDistance',
                                                                 'Unit')}}],
                            'setUnit': [{'argInfo': {'newUnit': {'doc': 'an element of the MDistance::Unit enum',
                                                                 'type': ('MDistance',
                                                                          'Unit')}},
                                         'args': [('newUnit',
                                                   ('MDistance',
                                                    'Unit'),
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSet the units used by this instance.',
                                         'inArgs': ['newUnit'],
                                         'inverse': ('unit', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'newUnit': []},
                                         'types': {'newUnit': ('MDistance',
                                                               'Unit')}}],
                            'setValue': [{'argInfo': {'newValue': {'doc': 'the new value in the units currently in effect',
                                                                   'type': 'double'}},
                                          'args': [('newValue',
                                                    'double',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nSet the value of this instance',
                                          'inArgs': ['newValue'],
                                          'inverse': ('value', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'newValue': []},
                                          'types': {'newValue': 'double'}}],
                            'uiToInternal': [{'argInfo': {'uiValue': {'doc': 'a value in UI units',
                                                                      'type': 'double'}},
                                              'args': [('uiValue',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nConverts a value from UI units to internal units.',
                                              'inArgs': ['uiValue'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value in internal units. ',
                                                             'qualifiers': [],
                                                             'type': 'double'},
                                              'returnType': 'double',
                                              'static': True,
                                              'typeQualifiers': {'uiValue': []},
                                              'types': {'uiValue': 'double'}}],
                            'uiUnit': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the Working Units (or UI units) chosen in the settings of the prefs window.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'An element of the MDistance::Unit enum ',
                                                       'qualifiers': [],
                                                       'type': ('MDistance',
                                                                'Unit')},
                                        'returnType': ('MDistance',
                                                       'Unit'),
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                            'unit': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn the units currently in effect for this instance.',
                                      'inArgs': [],
                                      'inverse': ('setUnit', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': ('MDistance',
                                                              'Unit')},
                                      'returnType': ('MDistance', 'Unit'),
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                            'value': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturn the value of the current instance in the currently set units.',
                                       'inArgs': [],
                                       'inverse': ('setValue', False),
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'double'},
                                       'returnType': 'double',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                'pymelEnums': {'Unit': "Enum('Unit', [('inches', 1), ('kInches', 1), ('feet', 2), ('kFeet', 2), ('yards', 3), ('kYards', 3), ('miles', 4), ('kMiles', 4), ('millimeters', 5), ('kMillimeters', 5), ('centimeters', 6), ('kCentimeters', 6), ('kilometers', 7), ('kKilometers', 7), ('meters', 8), ('kMeters', 8)], multiKeys=True)"},
                'pymelMethods': {'internalUnit': 'getInternalUnit',
                                 'unit': 'getUnit',
                                 'value': 'getValue'}},
  'MDoubleArray': {'enums': {},
                   'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                   ('setLength', 'length')],
                   'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                               'qualifiers': ['&'],
                                                               'type': 'double'},
                                                'returnType': 'double',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}},
                                               {'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The value of the indicated element. ',
                                                               'qualifiers': [],
                                                               'type': 'double'},
                                                'returnType': 'double',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                   'type': 'double'}},
                                           'args': [('element',
                                                     'double',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': []},
                                           'types': {'element': 'double'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                'type': 'MDoubleArray'}},
                                         'args': [('source',
                                                   'MDoubleArray',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nCopy the contents of the source array to this array.',
                                         'inArgs': ['source'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'source': ['const',
                                                                       '&']},
                                         'types': {'source': 'MDoubleArray'}}],
                               'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                              'type': 'double__array'}},
                                        'args': [('array',
                                                  'double__array',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopy the elements of the array into the given C++ array of doubles. No checking is done to ensure that the destination C++ array of doubles is large enough to hold all the elements of the instance.',
                                        'inArgs': [],
                                        'outArgs': ['array'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'array': []},
                                        'types': {'array': 'double__array'}},
                                       {'argInfo': {'array': {'doc': 'the array to populate',
                                                              'type': 'float__array'}},
                                        'args': [('array',
                                                  'float__array',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopy the elements of the array into the given C++ array of floats. No checking is done to ensure that the destination C++ array of floats is large enough to hold all the elements of the instance.',
                                        'inArgs': [],
                                        'outArgs': ['array'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'array': []},
                                        'types': {'array': 'float__array'}}],
                               'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                   'type': 'double'},
                                                       'index': {'doc': 'the index of the element to set to the the new value',
                                                                 'type': 'uint'}},
                                           'args': [('element',
                                                     'double',
                                                     'in'),
                                                    ('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element', 'index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': [],
                                                              'index': ['unsigned']},
                                           'types': {'element': 'double',
                                                     'index': 'uint'}}],
                               'length': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the number of elements in the instance.',
                                           'inArgs': [],
                                           'inverse': ('setLength',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of elements in the instance ',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned']},
                                           'types': {'index': 'uint'}}],
                               'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'double'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'double',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the value of the indicated element to the indicated double value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': [],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'double',
                                                  'index': 'uint'}},
                                       {'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'float'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'float',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the value of the indicated element to the indicated float value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': [],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'float',
                                                  'index': 'uint'}}],
                               'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                     'type': 'uint'}},
                                              'args': [('length',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                              'inArgs': ['length'],
                                              'inverse': ('length', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'length': ['unsigned']},
                                              'types': {'length': 'uint'}}],
                               'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                  'type': 'uint'}},
                                                     'args': [('newIncrement',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                     'inArgs': ['newIncrement'],
                                                     'inverse': ('sizeIncrement',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'newIncrement': ['unsigned']},
                                                     'types': {'newIncrement': 'uint'}}],
                               'sizeIncrement': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                  'inArgs': [],
                                                  'inverse': ('setSizeIncrement',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'length': 'getLength',
                                    'sizeIncrement': 'getSizeIncrement'}},
  'MDrawData': {'enums': {},
                'methods': {'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'geometry': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the geometry associated with this draw data object. The geometry is set using the getDrawData method of  MPxSurfaceShapeUI .',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                'pymelEnums': {}},
  'MDrawInfo': {'enums': {},
                'invertibles': [('setMultiPath', 'multiPath')],
                'methods': {'canDrawComponent': [{'argInfo': {'isDisplayOn': {'doc': 'component display is on ',
                                                                              'type': 'bool'},
                                                              'mask': {'doc': 'component mask to test',
                                                                       'type': 'MSelectionMask'}},
                                                  'args': [('isDisplayOn',
                                                            'bool',
                                                            'in'),
                                                           ('mask',
                                                            'MSelectionMask',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nConvenience method to test if components specified by the given mask can be drawn.',
                                                  'inArgs': ['isDisplayOn',
                                                             'mask'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' true the specified component can be drawn  false the specified component cannot be drawn   ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'isDisplayOn': [],
                                                                     'mask': ['const',
                                                                              '&']},
                                                  'types': {'isDisplayOn': 'bool',
                                                            'mask': 'MSelectionMask'}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'completelyInside': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns true if the object being drawn is inside the viewing frustum.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                            'displayStatus': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the status of the object to draw.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Object display status ',
                                                              'qualifiers': [],
                                                              'type': ('M3dView',
                                                                       'DisplayStatus')},
                                               'returnType': ('M3dView',
                                                              'DisplayStatus'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                            'displayStyle': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThe display appearance.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The display appearance. ',
                                                             'qualifiers': [],
                                                             'type': ('M3dView',
                                                                      'DisplayStyle')},
                                              'returnType': ('M3dView',
                                                             'DisplayStyle'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                            'getPrototype': [{'argInfo': {'drawHandler': {'doc': 'the ui object that is doing the drawing',
                                                                          'type': 'MPxSurfaceShapeUI'}},
                                              'args': [('drawHandler',
                                                        'MPxSurfaceShapeUI',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method creates a draw request based on the current draw state.',
                                              'inArgs': ['drawHandler'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A draw request ',
                                                             'qualifiers': [],
                                                             'type': 'MDrawRequest'},
                                              'returnType': 'MDrawRequest',
                                              'static': False,
                                              'typeQualifiers': {'drawHandler': ['const',
                                                                                 '&']},
                                              'types': {'drawHandler': 'MPxSurfaceShapeUI'}}],
                            'inSelect': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns true if this is called from within the select method of  MPxSurfaceShapeUI .',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                            'inUserInteraction': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns true during any interactive refresh, as when user is interacting with the scene in any way including camera changes, object or component TRS changes, etc. Use userChangingViewContext for determining whether user is changing the view using view context tools such as tumble, dolly or track.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                            'inclusiveMatrix': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the world space inclusive matrix.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MMatrix'},
                                                 'returnType': 'MMatrix',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                            'multiPath': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the path to the object to be drawn.',
                                           'inArgs': [],
                                           'inverse': ('setMultiPath',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The path to the object to be drawn ',
                                                          'qualifiers': [],
                                                          'type': 'MDagPath'},
                                           'returnType': 'MDagPath',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'pluginObjectDisplayStatus': [{'argInfo': {'pluginDisplayFilter': {'doc': 'The name of the plugin display filter which is registered by pluginDisplayFilter command.',
                                                                                               'type': 'MString'}},
                                                           'args': [('pluginDisplayFilter',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nDetermines whether the specified plugin object is allowed to be displayed.',
                                                           'inArgs': ['pluginDisplayFilter'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' true The specified object can be displayed.  false The specified object is excluded from display.   ',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'pluginDisplayFilter': ['const',
                                                                                                      '&']},
                                                           'types': {'pluginDisplayFilter': 'MString'}}],
                            'projectionMatrix': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the camera*projection matrix.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MMatrix'},
                                                  'returnType': 'MMatrix',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                            'setMultiPath': [{'argInfo': {'dagPath': {'doc': '',
                                                                      'type': 'MDagPath'}},
                                              'args': [('dagPath',
                                                        'MDagPath',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets the path of the object to be drawn. \r\n',
                                              'inArgs': ['dagPath'],
                                              'inverse': ('multiPath',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'dagPath': ['const',
                                                                             '&']},
                                              'types': {'dagPath': 'MDagPath'}}],
                            'userChangingViewContext': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns true during any interactive refresh, as when user is changing the view using view context tools such as tumble, dolly or track. Useful for changing drawing mode to something simpler to speed up interaction re-draw. Use inUserInteraction for determining whether user is interacting with the scene in any way.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                            'view': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturns the view that the drawing will take place.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The view ',
                                                     'qualifiers': [],
                                                     'type': 'M3dView'},
                                      'returnType': 'M3dView',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}]},
                'pymelEnums': {},
                'pymelMethods': {'multiPath': 'getMultiPath'}},
  'MDrawProcedureBase': {'enums': {},
                         'invertibles': [('setEnabled', 'enabled'),
                                         ('setName', 'name')],
                         'methods': {'enabled': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method returns whether the draw procedure is enabled or not.',
                                                  'inArgs': [],
                                                  'inverse': ('setEnabled',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                     'execute': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method gets called by the renderer to execture the draw procedure. Derived class of  MDrawProcedureBase  must implement this method as it defined as a pure virtual method on this class. The implementation is free to perform any drawing functionality from within this method.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'True if execution was successful. ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                     'name': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method returns the name of the draw procedure. \r\n',
                                               'inArgs': [],
                                               'inverse': ('setName',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['&'],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                     'setEnabled': [{'argInfo': {'value': {'doc': 'Boolean value to set the enabling state. ',
                                                                           'type': 'bool'}},
                                                     'args': [('value',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method sets whether the draw procedure is enabled or not.',
                                                     'inArgs': ['value'],
                                                     'inverse': ('enabled',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'value': []},
                                                     'types': {'value': 'bool'}}],
                                     'setName': [{'argInfo': {'name': {'doc': 'Name to set. ',
                                                                       'type': 'MString'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method sets the name for the draw procedure.',
                                                  'inArgs': ['name'],
                                                  'inverse': ('name',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'name': ['const',
                                                                              '&']},
                                                  'types': {'name': 'MString'}}]},
                         'pymelEnums': {},
                         'pymelMethods': {'enabled': 'getEnabled',
                                          'name': 'getName'}},
  'MDrawRequest': {'enums': {},
                   'invertibles': [('setMatrix', 'matrix'),
                                   ('setDisplayCullOpposite',
                                    'displayCullOpposite'),
                                   ('setDrawLast', 'drawLast'),
                                   ('setMaterial', 'material'),
                                   ('setComponent', 'component'),
                                   ('setDisplayStyle', 'displayStyle'),
                                   ('setDisplayCulling', 'displayCulling'),
                                   ('setView', 'view'),
                                   ('setDrawData', 'drawData'),
                                   ('setMultiPath', 'multiPath'),
                                   ('setColor', 'color'),
                                   ('setDisplayStatus', 'displayStatus'),
                                   ('setIsTransparent', 'isTransparent')],
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'color': [{'argInfo': {'table': {'doc': 'color table ',
                                                                'type': ('M3dView',
                                                                         'ColorTable')}},
                                          'args': [('table',
                                                    ('M3dView',
                                                     'ColorTable'),
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the wireframe display color.',
                                          'inArgs': ['table'],
                                          'inverse': ('setColor', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {'table': []},
                                          'types': {'table': ('M3dView',
                                                              'ColorTable')}},
                                         {'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the RGBA wireframe display color.',
                                          'inArgs': [],
                                          'inverse': ('setColor', False),
                                          'outArgs': [],
                                          'pymelName': 'getColor',
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'MColor'},
                                          'returnType': 'MColor',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'component': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nAn optional component. If set draw the components that are specified, otherwise draw all components of this type for the object. \r\n  Reprocessed example  \n Examples: \n \n   \n apiMeshShapeUI.cpp . \n \n',
                                              'inArgs': [],
                                              'inverse': ('setComponent',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'displayCullOpposite': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the state of the culling flag for the object. \r\n',
                                                        'inArgs': [],
                                                        'inverse': ('setDisplayCullOpposite',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                               'displayCulling': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the state of the culling flag for the object. \r\n',
                                                   'inArgs': [],
                                                   'inverse': ('setDisplayCulling',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                               'displayStatus': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the state of object (active, dormant, etc.). \r\n',
                                                  'inArgs': [],
                                                  'inverse': ('setDisplayStatus',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': ('M3dView',
                                                                          'DisplayStatus')},
                                                  'returnType': ('M3dView',
                                                                 'DisplayStatus'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'displayStyle': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns how the object should be drawn (wireframe, shaded, etc.). \r\n',
                                                 'inArgs': [],
                                                 'inverse': ('setDisplayStyle',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('M3dView',
                                                                         'DisplayStyle')},
                                                 'returnType': ('M3dView',
                                                                'DisplayStyle'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'drawData': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the object specific draw data. \r\n  Reprocessed example  \n Examples: \n \n   \n apiMeshShapeUI.cpp ,  pnTrianglesNode.cpp , and  quadricShape.cpp . \n \n',
                                             'inArgs': [],
                                             'inverse': ('setDrawData',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'MDrawData'},
                                             'returnType': 'MDrawData',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                               'drawLast': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the order in which this object will be drawn. \r\n',
                                             'inArgs': [],
                                             'inverse': ('setDrawLast',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                               'isTransparent': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the transparency state of the object. \r\n  Reprocessed example  \n Examples: \n \n   \n apiMeshShapeUI.cpp , and  quadricShape.cpp . \n \n',
                                                  'inArgs': [],
                                                  'inverse': ('setIsTransparent',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'material': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the shaded material. \r\n  Reprocessed example  \n Examples: \n \n   \n apiMeshShapeUI.cpp ,  pnTrianglesNode.cpp , and  quadricShape.cpp . \n \n',
                                             'inArgs': [],
                                             'inverse': ('setMaterial',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'MMaterial'},
                                             'returnType': 'MMaterial',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                               'matrix': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the draw matrix.',
                                           'inArgs': [],
                                           'inverse': ('setMatrix',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['&'],
                                                          'type': 'MMatrix'},
                                           'returnType': 'MMatrix',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'multiPath': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the path to the object to be drawn. \r\n  Reprocessed example  \n Examples: \n \n   \n apiMeshShapeUI.cpp ,  blindDataShader.cpp ,  hwAnisotropicShader_NV20.cpp ,  hwDecalBumpShader_NV20.cpp ,  hwReflectBumpShader_NV20.cpp ,  hwRefractReflectShader_NV20.cpp ,  hwToonShader_NV20.cpp ,  hwUnlitShader.cpp ,  pnTrianglesNode.cpp , and  quadricShape.cpp . \n \n',
                                              'inArgs': [],
                                              'inverse': ('setMultiPath',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MDagPath'},
                                              'returnType': 'MDagPath',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'setColor': [{'argInfo': {'table': {'doc': 'color table ',
                                                                   'type': ('M3dView',
                                                                            'ColorTable')},
                                                         'value': {'doc': 'index into the color table ',
                                                                   'type': 'int'}},
                                             'args': [('value',
                                                       'int',
                                                       'in'),
                                                      ('table',
                                                       ('M3dView',
                                                        'ColorTable'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the wireframe display color.',
                                             'inArgs': ['value', 'table'],
                                             'inverse': ('color', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'table': [],
                                                                'value': []},
                                             'types': {'table': ('M3dView',
                                                                 'ColorTable'),
                                                       'value': 'int'}},
                                            {'argInfo': {'color': {'doc': 'The RGBA wireframe color ',
                                                                   'type': 'MColor'}},
                                             'args': [('color',
                                                       'MColor',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the RGBA wireframe display color.',
                                             'inArgs': ['color'],
                                             'inverse': ('color', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'color': ['const',
                                                                          '&']},
                                             'types': {'color': 'MColor'}}],
                               'setComponent': [{'argInfo': {'comp': {'doc': 'component to be drawn ',
                                                                      'type': 'MObject'}},
                                                 'args': [('comp',
                                                           'MObject',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet a component to be drawn.',
                                                 'inArgs': ['comp'],
                                                 'inverse': ('component',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'comp': ['&']},
                                                 'types': {'comp': 'MObject'}}],
                               'setDisplayCullOpposite': [{'argInfo': {'value': {'doc': 'culling value to be set ',
                                                                                 'type': 'bool'}},
                                                           'args': [('value',
                                                                     'bool',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSets the state of the culling flag for the object.',
                                                           'inArgs': ['value'],
                                                           'inverse': ('displayCullOpposite',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'value': []},
                                                           'types': {'value': 'bool'}}],
                               'setDisplayCulling': [{'argInfo': {'value': {'doc': 'culling value to be set ',
                                                                            'type': 'bool'}},
                                                      'args': [('value',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the state of the culling flag for the object.',
                                                      'inArgs': ['value'],
                                                      'inverse': ('displayCulling',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'value': []},
                                                      'types': {'value': 'bool'}}],
                               'setDisplayStatus': [{'argInfo': {'status': {'doc': 'display status ',
                                                                            'type': ('M3dView',
                                                                                     'DisplayStatus')}},
                                                     'args': [('status',
                                                               ('M3dView',
                                                                'DisplayStatus'),
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the state of object (active, dormant, etc.).',
                                                     'inArgs': ['status'],
                                                     'inverse': ('displayStatus',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'status': []},
                                                     'types': {'status': ('M3dView',
                                                                          'DisplayStatus')}}],
                               'setDisplayStyle': [{'argInfo': {'style': {'doc': 'display style to set ',
                                                                          'type': ('M3dView',
                                                                                   'DisplayStyle')}},
                                                    'args': [('style',
                                                              ('M3dView',
                                                               'DisplayStyle'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets how the object should be drawn (wireframe, shaded, etc.).',
                                                    'inArgs': ['style'],
                                                    'inverse': ('displayStyle',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'style': []},
                                                    'types': {'style': ('M3dView',
                                                                        'DisplayStyle')}}],
                               'setDrawData': [{'argInfo': {'data': {'doc': 'draw data ',
                                                                     'type': 'MDrawData'}},
                                                'args': [('data',
                                                          'MDrawData',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet the object specific draw data.',
                                                'inArgs': ['data'],
                                                'inverse': ('drawData',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'data': ['&']},
                                                'types': {'data': 'MDrawData'}}],
                               'setDrawLast': [{'argInfo': {'value': {'doc': 'draw last flag ',
                                                                      'type': 'bool'}},
                                                'args': [('value',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSpecifies the order in which this object will be drawn.',
                                                'inArgs': ['value'],
                                                'inverse': ('drawLast',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': 'bool'}}],
                               'setIsTransparent': [{'argInfo': {'value': {'doc': 'the transparency value ',
                                                                           'type': 'bool'}},
                                                     'args': [('value',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the transparency state of the object.',
                                                     'inArgs': ['value'],
                                                     'inverse': ('isTransparent',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'value': []},
                                                     'types': {'value': 'bool'}}],
                               'setMaterial': [{'argInfo': {'material': {'doc': 'the material to set ',
                                                                         'type': 'MMaterial'}},
                                                'args': [('material',
                                                          'MMaterial',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the shaded material.',
                                                'inArgs': ['material'],
                                                'inverse': ('material',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'material': ['&']},
                                                'types': {'material': 'MMaterial'}}],
                               'setMatrix': [{'argInfo': {'value': {'doc': 'The matrix to set. ',
                                                                    'type': 'MMatrix'}},
                                              'args': [('value',
                                                        'MMatrix',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the draw matrix.',
                                              'inArgs': ['value'],
                                              'inverse': ('matrix', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'value': ['const',
                                                                           '&']},
                                              'types': {'value': 'MMatrix'}}],
                               'setMultiPath': [{'argInfo': {'thePath': {'doc': '',
                                                                         'type': 'MDagPath'}},
                                                 'args': [('thePath',
                                                           'MDagPath',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the path to the object to be drawn. \r\n',
                                                 'inArgs': ['thePath'],
                                                 'inverse': ('multiPath',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'thePath': ['const',
                                                                                '&']},
                                                 'types': {'thePath': 'MDagPath'}}],
                               'setView': [{'argInfo': {'theView': {'doc': '',
                                                                    'type': 'M3dView'}},
                                            'args': [('theView',
                                                      'M3dView',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets the view where drawing will be done. \r\n',
                                            'inArgs': ['theView'],
                                            'inverse': ('view', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'theView': ['&']},
                                            'types': {'theView': 'M3dView'}}],
                               'token': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the user-defined draw token for this request.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'view': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the view where drawing will be done. \r\n',
                                         'inArgs': [],
                                         'inverse': ('setView', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'M3dView'},
                                         'returnType': 'M3dView',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'color': 'getColor',
                                    'component': 'getComponent',
                                    'displayCullOpposite': 'getDisplayCullOpposite',
                                    'displayCulling': 'getDisplayCulling',
                                    'displayStatus': 'getDisplayStatus',
                                    'displayStyle': 'getDisplayStyle',
                                    'drawData': 'getDrawData',
                                    'drawLast': 'getDrawLast',
                                    'material': 'getMaterial',
                                    'matrix': 'getMatrix',
                                    'multiPath': 'getMultiPath',
                                    'setIsTransparent': 'setTransparent',
                                    'view': 'getView'}},
  'MDrawRequestQueue': {'enums': {},
                        'methods': {'add': [{'argInfo': {'request': {'doc': 'the draw request to add ',
                                                                     'type': 'MDrawRequest'}},
                                             'args': [('request',
                                                       'MDrawRequest',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nAdds a draw request to the draw queue.',
                                             'inArgs': ['request'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'request': ['&']},
                                             'types': {'request': 'MDrawRequest'}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'isEmpty': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if the queu is empty.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'remove': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRemoves a draw request from the draw queue.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'MDrawRequest'},
                                                'returnType': 'MDrawRequest',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                        'pymelEnums': {}},
  'MDrawTraversal': {'enums': {},
                     'invertibles': [('setLeafLevelCulling',
                                      'leafLevelCulling')],
                     'methods': {'enableFiltering': [{'argInfo': {'val': {'doc': 'value for enabling. ',
                                                                          'type': 'bool'}},
                                                      'args': [('val',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets whether to use enable usage of the  filterNode()  method to perform custom filtering. By default this is set to false.',
                                                      'inArgs': ['val'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'val': []},
                                                      'types': {'val': 'bool'}}],
                                 'filterNode': [{'argInfo': {'traversalItem': {'doc': 'path to item to test.',
                                                                               'type': 'MDagPath'}},
                                                 'args': [('traversalItem',
                                                           'MDagPath',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nMethod to allow filtering during traversal. The traversalItem can be examined, and if it is not match the desired criteria, it will not be added to the output traversal list.',
                                                 'inArgs': ['traversalItem'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Will always return false for MDrawTraversal class. ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'traversalItem': ['const',
                                                                                      '&']},
                                                 'types': {'traversalItem': 'MDagPath'}}],
                                 'filteringEnabled': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nTells whether custom filtering has been enabled. That is, to use the  filterNode()  method during traversal.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                 'frustumValid': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns whether the current frustum set is valid or not. If it is not valid a call to the  traverse()  function will result in returning failure.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'true if frustum is valid. ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'itemHasStatus': [{'argInfo': {'itemNumber': {'doc': 'which item to return. ',
                                                                               'type': 'uint'},
                                                                'test': {'doc': 'the display status to check the item against.',
                                                                         'type': 'uint'}},
                                                    'args': [('itemNumber',
                                                              'uint',
                                                              'in'),
                                                             ('test',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nTest the display status for a given item in the list of found items after traversal.',
                                                    'inArgs': ['itemNumber',
                                                               'test'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'true, if item status matches the display status to test against. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'itemNumber': ['unsigned'],
                                                                       'test': ['unsigned']},
                                                    'types': {'itemNumber': 'uint',
                                                              'test': 'uint'}}],
                                 'itemPath': [{'argInfo': {'itemNumber': {'doc': 'which item to return. ',
                                                                          'type': 'uint'},
                                                           'path': {'doc': 'path of item (returned).',
                                                                    'type': 'MDagPath'}},
                                               'args': [('itemNumber',
                                                         'uint',
                                                         'in'),
                                                        ('path',
                                                         'MDagPath',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the path for a given item in the list of found items after traversal.',
                                               'inArgs': ['itemNumber'],
                                               'outArgs': ['path'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'itemNumber': ['unsigned'],
                                                                  'path': ['&']},
                                               'types': {'itemNumber': 'uint',
                                                         'path': 'MDagPath'}}],
                                 'leafLevelCulling': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns whether the current cull algorithm will cull at the leaf levels, or perform hierarchical culling. The default value is leaf level culling.',
                                                       'inArgs': [],
                                                       'inverse': ('setLeafLevelCulling',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                 'numberOfItems': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the number of items found after traversal.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Number of items. ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                 'setFrustum': [{'argInfo': {'cameraPath': {'doc': 'path to a valid scene camera. ',
                                                                            'type': 'MDagPath'},
                                                             'portHeight': {'doc': 'height of the viewport to cull against.',
                                                                            'type': 'uint'},
                                                             'portWidth': {'doc': 'width of the viewport to cull against. ',
                                                                           'type': 'uint'}},
                                                 'args': [('cameraPath',
                                                           'MDagPath',
                                                           'in'),
                                                          ('portWidth',
                                                           'uint',
                                                           'in'),
                                                          ('portHeight',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet the frustum to cull with. The frustum is based on the attributes of the camera argument provided.',
                                                 'inArgs': ['cameraPath',
                                                            'portWidth',
                                                            'portHeight'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'cameraPath': ['const',
                                                                                   '&'],
                                                                    'portHeight': ['unsigned'],
                                                                    'portWidth': ['unsigned']},
                                                 'types': {'cameraPath': 'MDagPath',
                                                           'portHeight': 'uint',
                                                           'portWidth': 'uint'}},
                                                {'argInfo': {'bottom': {'doc': 'Bottom of frustum (local space). ',
                                                                        'type': 'double'},
                                                             'farpt': {'doc': 'Back / far point of frustum (local space). ',
                                                                       'type': 'double'},
                                                             'left': {'doc': 'Left side of frustum (local space). ',
                                                                      'type': 'double'},
                                                             'nearpt': {'doc': 'Front / near point of frustum (local space). ',
                                                                        'type': 'double'},
                                                             'right': {'doc': 'Right side of frustum (local space). ',
                                                                       'type': 'double'},
                                                             'top': {'doc': 'Top of frustum (local space). ',
                                                                     'type': 'double'},
                                                             'worldXform': {'doc': 'transformation from local to world space.',
                                                                            'type': 'MMatrix'}},
                                                 'args': [('left',
                                                           'double',
                                                           'in'),
                                                          ('right',
                                                           'double',
                                                           'in'),
                                                          ('bottom',
                                                           'double',
                                                           'in'),
                                                          ('top',
                                                           'double',
                                                           'in'),
                                                          ('nearpt',
                                                           'double',
                                                           'in'),
                                                          ('farpt',
                                                           'double',
                                                           'in'),
                                                          ('worldXform',
                                                           'MMatrix',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet up a frustum to cull with. The frustum can be asymmetric is distance about the vertial and horizontal.',
                                                 'inArgs': ['left',
                                                            'right',
                                                            'bottom',
                                                            'top',
                                                            'nearpt',
                                                            'farpt',
                                                            'worldXform'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'bottom': [],
                                                                    'farpt': [],
                                                                    'left': [],
                                                                    'nearpt': [],
                                                                    'right': [],
                                                                    'top': [],
                                                                    'worldXform': ['const',
                                                                                   '&']},
                                                 'types': {'bottom': 'double',
                                                           'farpt': 'double',
                                                           'left': 'double',
                                                           'nearpt': 'double',
                                                           'right': 'double',
                                                           'top': 'double',
                                                           'worldXform': 'MMatrix'}},
                                                {'argInfo': {'farBottomLeft': {'doc': 'Far bottom left corner of frustum (local space). ',
                                                                               'type': 'MPoint'},
                                                             'farBottomRight': {'doc': 'Far bottom right corner of frustum (local space). ',
                                                                                'type': 'MPoint'},
                                                             'farTopLeft': {'doc': 'Far top left corner of frustum (local space). ',
                                                                            'type': 'MPoint'},
                                                             'farTopRight': {'doc': 'Far top right corner of frustum (local space). ',
                                                                             'type': 'MPoint'},
                                                             'nearBottomLeft': {'doc': 'Near bottom left corner of frustum (local space). ',
                                                                                'type': 'MPoint'},
                                                             'nearBottomRight': {'doc': 'Near bottom Right corner of frustum (local space). ',
                                                                                 'type': 'MPoint'},
                                                             'nearTopLeft': {'doc': 'Near top left corner of frustum (local space). ',
                                                                             'type': 'MPoint'},
                                                             'nearTopRight': {'doc': 'Near top right corner of frustum (local space). ',
                                                                              'type': 'MPoint'},
                                                             'worldXform': {'doc': 'transformation from local to world space.',
                                                                            'type': 'MMatrix'}},
                                                 'args': [('nearBottomLeft',
                                                           'MPoint',
                                                           'in'),
                                                          ('nearBottomRight',
                                                           'MPoint',
                                                           'in'),
                                                          ('nearTopLeft',
                                                           'MPoint',
                                                           'in'),
                                                          ('nearTopRight',
                                                           'MPoint',
                                                           'in'),
                                                          ('farBottomLeft',
                                                           'MPoint',
                                                           'in'),
                                                          ('farBottomRight',
                                                           'MPoint',
                                                           'in'),
                                                          ('farTopLeft',
                                                           'MPoint',
                                                           'in'),
                                                          ('farTopRight',
                                                           'MPoint',
                                                           'in'),
                                                          ('worldXform',
                                                           'MMatrix',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nSet up a frustum to cull with by specifying the 8 corner points. Asymmetric frustum's can be set up using this method.",
                                                 'inArgs': ['nearBottomLeft',
                                                            'nearBottomRight',
                                                            'nearTopLeft',
                                                            'nearTopRight',
                                                            'farBottomLeft',
                                                            'farBottomRight',
                                                            'farTopLeft',
                                                            'farTopRight',
                                                            'worldXform'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'farBottomLeft': ['const',
                                                                                      '&'],
                                                                    'farBottomRight': ['const',
                                                                                       '&'],
                                                                    'farTopLeft': ['const',
                                                                                   '&'],
                                                                    'farTopRight': ['const',
                                                                                    '&'],
                                                                    'nearBottomLeft': ['const',
                                                                                       '&'],
                                                                    'nearBottomRight': ['const',
                                                                                        '&'],
                                                                    'nearTopLeft': ['const',
                                                                                    '&'],
                                                                    'nearTopRight': ['const',
                                                                                     '&'],
                                                                    'worldXform': ['const',
                                                                                   '&']},
                                                 'types': {'farBottomLeft': 'MPoint',
                                                           'farBottomRight': 'MPoint',
                                                           'farTopLeft': 'MPoint',
                                                           'farTopRight': 'MPoint',
                                                           'nearBottomLeft': 'MPoint',
                                                           'nearBottomRight': 'MPoint',
                                                           'nearTopLeft': 'MPoint',
                                                           'nearTopRight': 'MPoint',
                                                           'worldXform': 'MMatrix'}}],
                                 'setLeafLevelCulling': [{'argInfo': {'cullAtLeafLevel': {'doc': 'flag to indicate culling preference.',
                                                                                          'type': 'bool'}},
                                                          'args': [('cullAtLeafLevel',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSet whether to cull at the leaf levels, or perform hierarchical culling.',
                                                          'inArgs': ['cullAtLeafLevel'],
                                                          'inverse': ('leafLevelCulling',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'cullAtLeafLevel': []},
                                                          'types': {'cullAtLeafLevel': 'bool'}}],
                                 'setOrthoFrustum': [{'argInfo': {'bottom': {'doc': 'Bottom of frustum (local space). ',
                                                                             'type': 'double'},
                                                                  'farpt': {'doc': 'Back / far point of frustum (local space). ',
                                                                            'type': 'double'},
                                                                  'left': {'doc': 'Left side of frustum (local space). ',
                                                                           'type': 'double'},
                                                                  'nearpt': {'doc': 'Front / near point of frustum (local space). ',
                                                                             'type': 'double'},
                                                                  'right': {'doc': 'Right side of frustum (local space). ',
                                                                            'type': 'double'},
                                                                  'top': {'doc': 'Top of frustum (local space). ',
                                                                          'type': 'double'},
                                                                  'worldXform': {'doc': 'transformation from local to world space.',
                                                                                 'type': 'MMatrix'}},
                                                      'args': [('left',
                                                                'double',
                                                                'in'),
                                                               ('right',
                                                                'double',
                                                                'in'),
                                                               ('bottom',
                                                                'double',
                                                                'in'),
                                                               ('top',
                                                                'double',
                                                                'in'),
                                                               ('nearpt',
                                                                'double',
                                                                'in'),
                                                               ('farpt',
                                                                'double',
                                                                'in'),
                                                               ('worldXform',
                                                                'MMatrix',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet up an orthographic view frustum to cull with. The frustum is symmetric about the vertical and horizontal.',
                                                      'inArgs': ['left',
                                                                 'right',
                                                                 'bottom',
                                                                 'top',
                                                                 'nearpt',
                                                                 'farpt',
                                                                 'worldXform'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'bottom': [],
                                                                         'farpt': [],
                                                                         'left': [],
                                                                         'nearpt': [],
                                                                         'right': [],
                                                                         'top': [],
                                                                         'worldXform': ['const',
                                                                                        '&']},
                                                      'types': {'bottom': 'double',
                                                                'farpt': 'double',
                                                                'left': 'double',
                                                                'nearpt': 'double',
                                                                'right': 'double',
                                                                'top': 'double',
                                                                'worldXform': 'MMatrix'}}],
                                 'setPerspFrustum': [{'argInfo': {'aspectXY': {'doc': 'aspect ratio X / Y. ',
                                                                               'type': 'double'},
                                                                  'farDist': {'doc': 'distance to far plane. ',
                                                                              'type': 'double'},
                                                                  'fovX': {'doc': 'Field of view in X. ',
                                                                           'type': 'double'},
                                                                  'nearDist': {'doc': 'distance to near plane. ',
                                                                               'type': 'double'},
                                                                  'worldXform': {'doc': 'transformation from local to world space.',
                                                                                 'type': 'MMatrix'}},
                                                      'args': [('fovX',
                                                                'double',
                                                                'in'),
                                                               ('aspectXY',
                                                                'double',
                                                                'in'),
                                                               ('nearDist',
                                                                'double',
                                                                'in'),
                                                               ('farDist',
                                                                'double',
                                                                'in'),
                                                               ('worldXform',
                                                                'MMatrix',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet up an perspective view frustum to cull with. The frustum is symmetric about the vertical and horizontal.',
                                                      'inArgs': ['fovX',
                                                                 'aspectXY',
                                                                 'nearDist',
                                                                 'farDist',
                                                                 'worldXform'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'aspectXY': [],
                                                                         'farDist': [],
                                                                         'fovX': [],
                                                                         'nearDist': [],
                                                                         'worldXform': ['const',
                                                                                        '&']},
                                                      'types': {'aspectXY': 'double',
                                                                'farDist': 'double',
                                                                'fovX': 'double',
                                                                'nearDist': 'double',
                                                                'worldXform': 'MMatrix'}}],
                                 'traverse': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nPerform traversal of the current scene from the root of the dag hierarchy. A valid frustum must be set before calling this method.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'leafLevelCulling': 'getLeafLevelCulling'}},
  'MDynSweptLine': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'length': [{'argInfo': {'t': {'doc': 'time value in the range 1.0 to 0.0  t=1.0 is the current frame  t=0.0 is the previous frame  ',
                                                              'type': 'double'}},
                                            'args': [('t',
                                                      'double',
                                                      'in')],
                                            'defaults': {'t': 1.0},
                                            'deprecated': False,
                                            'doc': "\r\nGiven a parametric time specified by 't', returns the total length of the line.",
                                            'inArgs': ['t'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Total line length ',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'t': []},
                                            'types': {'t': 'double'}}],
                                'normal': [{'argInfo': {'t': {'doc': 'time value in the range 1.0 to 0.0  t=1.0 is the current frame  t=0.0 is the previous frame  ',
                                                              'type': 'double'},
                                                        'x': {'doc': 'x component of a vector ',
                                                              'type': 'double'},
                                                        'y': {'doc': 'y component of a vector ',
                                                              'type': 'double'},
                                                        'z': {'doc': 'z component of a vector ',
                                                              'type': 'double'}},
                                            'args': [('x',
                                                      'double',
                                                      'in'),
                                                     ('y',
                                                      'double',
                                                      'in'),
                                                     ('z',
                                                      'double',
                                                      'in'),
                                                     ('t',
                                                      'double',
                                                      'in')],
                                            'defaults': {'t': 1.0},
                                            'deprecated': False,
                                            'doc': "\r\nGiven a parametric time specified by 't' and a vector, returns a normalized vector perpendicular to the tangent, and rotated into the plane defined by the tangent and vector argument.",
                                            'inArgs': ['x',
                                                       'y',
                                                       'z',
                                                       't'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A normalized vector ',
                                                           'qualifiers': [],
                                                           'type': 'MVector'},
                                            'returnType': 'MVector',
                                            'static': False,
                                            'typeQualifiers': {'t': [],
                                                               'x': [],
                                                               'y': [],
                                                               'z': []},
                                            'types': {'t': 'double',
                                                      'x': 'double',
                                                      'y': 'double',
                                                      'z': 'double'}}],
                                'tangent': [{'argInfo': {'t': {'doc': 'time value in the range 1.0 to 0.0  t=1.0 is the current frame  t=0.0 is the previous frame  ',
                                                               'type': 'double'}},
                                             'args': [('t',
                                                       'double',
                                                       'in')],
                                             'defaults': {'t': 1.0},
                                             'deprecated': False,
                                             'doc': "\r\nGiven a parametric time specified by 't', returns normalized tangent of the line.",
                                             'inArgs': ['t'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A normalized vector ',
                                                            'qualifiers': [],
                                                            'type': 'MVector'},
                                             'returnType': 'MVector',
                                             'static': False,
                                             'typeQualifiers': {'t': []},
                                             'types': {'t': 'double'}}],
                                'vertex': [{'argInfo': {'t': {'doc': 'time value in the range 1.0 to 0.0  t=1.0 is the current frame  t=0.0 is the previous frame  ',
                                                              'type': 'double'},
                                                        'vertexId': {'doc': 'index 0 or 1 ',
                                                                     'type': 'int'}},
                                            'args': [('vertexId',
                                                      'int',
                                                      'in'),
                                                     ('t',
                                                      'double',
                                                      'in')],
                                            'defaults': {'t': 1.0},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the vertex requested by id, at the parametric time value.',
                                            'inArgs': ['vertexId', 't'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The vertex position ',
                                                           'qualifiers': [],
                                                           'type': 'MVector'},
                                            'returnType': 'MVector',
                                            'static': False,
                                            'typeQualifiers': {'t': [],
                                                               'vertexId': []},
                                            'types': {'t': 'double',
                                                      'vertexId': 'int'}}]},
                    'pymelEnums': {}},
  'MDynSweptTriangle': {'enums': {},
                        'methods': {'area': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method returns the area.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The area, as double value. ',
                                                             'qualifiers': [],
                                                             'type': 'double'},
                                              'returnType': 'double',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'normal': [{'argInfo': {'t': {'doc': 'time value in the range 1.0 to 0.0  t=1.0 is the current frame  t=0.0 is the previous frame  ',
                                                                  'type': 'double'}},
                                                'args': [('t',
                                                          'double',
                                                          'in')],
                                                'defaults': {'t': 1.0},
                                                'deprecated': False,
                                                'doc': "\r\nGiven a parametric time specified by 't', returns the normal of the triangle.",
                                                'inArgs': ['t'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A normalized vector ',
                                                               'qualifiers': [],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {'t': []},
                                                'types': {'t': 'double'}}],
                                    'normalToPoint': [{'argInfo': {'t': {'doc': 'time value in the range 1.0 to 0.0  t=1.0 is the current frame  t=0.0 is the previous frame  ',
                                                                         'type': 'double'},
                                                                   'x': {'doc': 'x component of the point ',
                                                                         'type': 'double'},
                                                                   'y': {'doc': 'y component of the point ',
                                                                         'type': 'double'},
                                                                   'z': {'doc': 'z component of the point ',
                                                                         'type': 'double'}},
                                                       'args': [('x',
                                                                 'double',
                                                                 'in'),
                                                                ('y',
                                                                 'double',
                                                                 'in'),
                                                                ('z',
                                                                 'double',
                                                                 'in'),
                                                                ('t',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {'t': 1.0},
                                                       'deprecated': False,
                                                       'doc': '\r\nGiven a point, returns the normal of the triangle in the direction towards the point. Determines which side of the triangle to return the normal.',
                                                       'inArgs': ['x',
                                                                  'y',
                                                                  'z',
                                                                  't'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A normalized vector ',
                                                                      'qualifiers': [],
                                                                      'type': 'MVector'},
                                                       'returnType': 'MVector',
                                                       'static': False,
                                                       'typeQualifiers': {'t': [],
                                                                          'x': [],
                                                                          'y': [],
                                                                          'z': []},
                                                       'types': {'t': 'double',
                                                                 'x': 'double',
                                                                 'y': 'double',
                                                                 'z': 'double'}}],
                                    'uvPoint': [{'argInfo': {'vertexId': {'doc': 'Id of the vertex for retrieving the UV point.',
                                                                          'type': 'int'}},
                                                 'args': [('vertexId',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGiven a vertex id, this method returns the UV point for the vertex as a  MVector .',
                                                 'inArgs': ['vertexId'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A vector. The u and v values are stored in the first two coordinates. The third coordinate is not meaningful. ',
                                                                'qualifiers': [],
                                                                'type': 'MVector'},
                                                 'returnType': 'MVector',
                                                 'static': False,
                                                 'typeQualifiers': {'vertexId': []},
                                                 'types': {'vertexId': 'int'}}],
                                    'vertex': [{'argInfo': {'t': {'doc': 'time value in the range 1.0 to 0.0  t=1.0 is the current frame  t=0.0 is the previous frame  ',
                                                                  'type': 'double'},
                                                            'vertexId': {'doc': 'index 0, 1, or 2 ',
                                                                         'type': 'int'}},
                                                'args': [('vertexId',
                                                          'int',
                                                          'in'),
                                                         ('t',
                                                          'double',
                                                          'in')],
                                                'defaults': {'t': 1.0},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the vertex requested by id, at the parametric time value.',
                                                'inArgs': ['vertexId',
                                                           't'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The vertex position. ',
                                                               'qualifiers': [],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {'t': [],
                                                                   'vertexId': []},
                                                'types': {'t': 'double',
                                                          'vertexId': 'int'}}]},
                        'pymelEnums': {}},
  'MDynamicsUtil': {'enums': {},
                    'methods': {'addNodeTypeToRunup': [{'argInfo': {'nodeTypeName': {'doc': 'node type to be included in runup.',
                                                                                     'type': 'MString'}},
                                                        'args': [('nodeTypeName',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nAdd this node to the list of nodes participating in runup. The node should respond to timeChanged and delayedTimeChangedRunup messages, or have a forceDynamics attribute. The node should have lastEvalTime and lastCacheTime attributes to determine whether runup is needed. Optionally the node may have a boolean checkForRunup attribute that when false will fully disable runup checking.',
                                                        'inArgs': ['nodeTypeName'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'true if the node was added to the list, false if it was already on the list ',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': True,
                                                        'typeQualifiers': {'nodeTypeName': ['const',
                                                                                            '&']},
                                                        'types': {'nodeTypeName': 'MString'}}],
                                'evalDynamics2dTexture': [{'argInfo': {'node': {'doc': 'node whose connected texture is to be evaluated. ',
                                                                                'type': 'MObject'},
                                                                       'resultAlphas': {'doc': 'if non-NULL, receives the outAlpha values evaluated from the texture at these same points.',
                                                                                        'type': 'MDoubleArray'},
                                                                       'resultColors': {'doc': "if non-NULL, receives the result of the connected texture's outColor attribute, evaluated at all the (u,v) coordinates given by the uCoords and vCoords arrays. ",
                                                                                        'type': 'MVectorArray'},
                                                                       'texAttr': {'doc': 'attribute whose connected texture is to be evaluated. ',
                                                                                   'type': 'MObject'},
                                                                       'uCoords': {'doc': 'array of u coordinate values ',
                                                                                   'type': 'MDoubleArray'},
                                                                       'vCoords': {'doc': 'array of v coordinate values ',
                                                                                   'type': 'MDoubleArray'}},
                                                           'args': [('node',
                                                                     'MObject',
                                                                     'in'),
                                                                    ('texAttr',
                                                                     'MObject',
                                                                     'in'),
                                                                    ('uCoords',
                                                                     'MDoubleArray',
                                                                     'in'),
                                                                    ('vCoords',
                                                                     'MDoubleArray',
                                                                     'in'),
                                                                    ('resultColors',
                                                                     'MVectorArray',
                                                                     'out'),
                                                                    ('resultAlphas',
                                                                     'MDoubleArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nIf a supported 2d texture (see  hasValidDynamics2dTexture()  method documentation) is connected to the specified attribute, this method can be called to evaluate that texture at a number of (u,v) texture coordinate values.',
                                                           'inArgs': ['node',
                                                                      'texAttr',
                                                                      'uCoords',
                                                                      'vCoords'],
                                                           'outArgs': ['resultColors',
                                                                       'resultAlphas'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': True,
                                                           'typeQualifiers': {'node': ['const',
                                                                                       '&'],
                                                                              'resultAlphas': ['*'],
                                                                              'resultColors': ['*'],
                                                                              'texAttr': ['const',
                                                                                          '&'],
                                                                              'uCoords': ['&'],
                                                                              'vCoords': ['&']},
                                                           'types': {'node': 'MObject',
                                                                     'resultAlphas': 'MDoubleArray',
                                                                     'resultColors': 'MVectorArray',
                                                                     'texAttr': 'MObject',
                                                                     'uCoords': 'MDoubleArray',
                                                                     'vCoords': 'MDoubleArray'}}],
                                'hasValidDynamics2dTexture': [{'argInfo': {'node': {'doc': 'node to be tested for a valid texture connection. ',
                                                                                    'type': 'MObject'},
                                                                           'texAttr': {'doc': 'attribute to be tested for a valid texture connection. ',
                                                                                       'type': 'MObject'}},
                                                               'args': [('node',
                                                                         'MObject',
                                                                         'in'),
                                                                        ('texAttr',
                                                                         'MObject',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': "\r\nCertain aspects of Maya's dynamics can be textured using 2d textures. For example, surface particle emitters can use a 2d texture to modulate the emission rate over the surface. For these purposes, only a subset of Maya's textures are supported, namely the default 2d textures (bulge, checker, cloth, file, fluid texture 2d, fractal, grid, mountain, movie, noise, ocean, ramp, water). No other nodes are supported. This method takes an attribute and determines if there is a supported texture connected to it. If the texture is supported, then the  evalDynamics2dTexture()  method can be called to evaluate the texture at various (u,v) coordinate values.",
                                                               'inArgs': ['node',
                                                                          'texAttr'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'true if the node connected to the specified attribute is a texture that can be evaluated using the evalDynamics2dTexture() method, false otherwise. ',
                                                                              'qualifiers': [],
                                                                              'type': 'bool'},
                                                               'returnType': 'bool',
                                                               'static': True,
                                                               'typeQualifiers': {'node': ['const',
                                                                                           '&'],
                                                                                  'status': ['*'],
                                                                                  'texAttr': ['const',
                                                                                              '&']},
                                                               'types': {'node': 'MObject',
                                                                         'texAttr': 'MObject'}}],
                                'inRunup': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nIs Maya's dynamics system currently doing a runup?",
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                'removeNodeTypeFromRunup': [{'argInfo': {'nodeTypeName': {'doc': 'node type to be removed from runup.',
                                                                                          'type': 'MString'}},
                                                             'args': [('nodeTypeName',
                                                                       'MString',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nRemove this node from the list of nodes participating in runup.',
                                                             'inArgs': ['nodeTypeName'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'true if the node was removed from the list, false if it was not on the list to start with ',
                                                                            'qualifiers': [],
                                                                            'type': 'bool'},
                                                             'returnType': 'bool',
                                                             'static': True,
                                                             'typeQualifiers': {'nodeTypeName': ['const',
                                                                                                 '&']},
                                                             'types': {'nodeTypeName': 'MString'}}],
                                'runupIfRequired': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nIf the dynamics runup prefs are set, do a runup',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}]},
                    'pymelEnums': {}},
  'MEdit': {'enums': {'EditType': {'valueDocs': {'addRemoveAttrEdit': 'Edit indicating an attribute added or removed.',
                                                 'connectDisconnectEdit': 'Edit indicating a connection or disconnection.',
                                                 'fcurveEdit': 'Edit indicating an fcurve modification.',
                                                 'kAddRemoveAttrEdit': 'Edit indicating an attribute added or removed.',
                                                 'kConnectDisconnectEdit': 'Edit indicating a connection or disconnection.',
                                                 'kFcurveEdit': 'Edit indicating an fcurve modification.',
                                                 'kNullEdit': 'Null edit.',
                                                 'kParentEdit': 'Edit indicating a parenting operation.',
                                                 'kSetAttrEdit': 'Edit indicating a change in plug value.',
                                                 'nullEdit': 'Null edit.',
                                                 'parentEdit': 'Edit indicating a parenting operation.',
                                                 'setAttrEdit': 'Edit indicating a change in plug value.'},
                                   'values': "Enum('EditType', {'kNullEdit': 0, 'kSetAttrEdit': 1, 'kConnectDisconnectEdit': 2, 'kAddRemoveAttrEdit': 3, 'kParentEdit': 4, 'kFcurveEdit': 5})"}},
            'invertibles': [('setApplied', 'isApplied'),
                            ('setFailed', 'isFailed')],
            'methods': {'className': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nReturns the name of this class.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': ['*'],
                                                      'type': 'char'},
                                       'returnType': 'char',
                                       'static': True,
                                       'typeQualifiers': {},
                                       'types': {}}],
                        'editType': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nReturns the enum related to the type of the current edit.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The current reference or assembly edit type or kNullEdit if there is no current edit',
                                                     'qualifiers': [],
                                                     'type': ('MEdit',
                                                              'EditType')},
                                      'returnType': ('MEdit', 'EditType'),
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                        'getString': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nReturns the ASCII string related to the current edit.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The ASCII string related to the current edit',
                                                      'qualifiers': [],
                                                      'type': 'MString'},
                                       'returnType': 'MString',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                        'hasEditData': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nQuery if the edit has any user-defined editData associated with it. See also  matches() .',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                        'isApplied': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nQuery if we attempted to apply the edit.',
                                       'inArgs': [],
                                       'inverse': ('setApplied', False),
                                       'outArgs': [],
                                       'returnInfo': {'doc': ' true We attempted to apply the edit.  false We did not attempt to apply the edit yet.  ',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                        'isFailed': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nQuery if the edit is applied successfully. One common cause of failed edit is it cannot find the node to apply the edit. They could be caused by the node name change or the node is not in the scene at the moment.',
                                      'inArgs': [],
                                      'inverse': ('setFailed', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' true The edit was applied successfully.  false The edit failed to be applied.  ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                        'isTopLevel': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nQuery if the edit was made from the top-level. Edits that were made from the top-level can be removed. But edits that were made in nested references/assemblies cannot be removed since they are part of another file.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': ' true The edit was made from the top-level.  false The edit was made in a nested reference/assembly.  ',
                                                       'qualifiers': [],
                                                       'type': 'bool'},
                                        'returnType': 'bool',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                        'matches': [{'argInfo': {'editData': {'doc': 'An editData object to compare with this object',
                                                              'type': 'MPxEditData'}},
                                     'args': [('editData',
                                               'MPxEditData',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\nQuery if the edit has user-defined editData associated with it that matches the given editData object.',
                                     'inArgs': ['editData'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': ' true The edit has matching associated editData  false The edit does not have matching associated editData   ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'editData': ['const',
                                                                     '*']},
                                     'types': {'editData': 'MPxEditData'}}],
                        'setApplied': [{'argInfo': {'isApplied': {'doc': 'Not used.',
                                                                  'type': 'bool'}},
                                        'args': [('isApplied',
                                                  'bool',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': ['isApplied'],
                                        'inverse': ('isApplied', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'isApplied': []},
                                        'types': {'isApplied': 'bool'}}],
                        'setFailed': [{'argInfo': {'failed': {'doc': 'Not used.',
                                                              'type': 'bool'}},
                                       'args': [('failed', 'bool', 'in')],
                                       'defaults': {},
                                       'deprecated': True,
                                       'doc': '\n This method is obsolete. \n',
                                       'inArgs': ['failed'],
                                       'inverse': ('isFailed', True),
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'failed': []},
                                       'types': {'failed': 'bool'}}]},
            'pymelEnums': {'EditType': "Enum('EditType', [('nullEdit', 0), ('kNullEdit', 0), ('setAttrEdit', 1), ('kSetAttrEdit', 1), ('connectDisconnectEdit', 2), ('kConnectDisconnectEdit', 2), ('addRemoveAttrEdit', 3), ('kAddRemoveAttrEdit', 3), ('parentEdit', 4), ('kParentEdit', 4), ('fcurveEdit', 5), ('kFcurveEdit', 5)], multiKeys=True)"}},
  'MEulerRotation': {'enums': {'RotationOrder': {'valueDocs': {'XYZ': '',
                                                               'XZY': '',
                                                               'YXZ': '',
                                                               'YZX': '',
                                                               'ZXY': '',
                                                               'ZYX': '',
                                                               'kXYZ': '',
                                                               'kXZY': '',
                                                               'kYXZ': '',
                                                               'kYZX': '',
                                                               'kZXY': '',
                                                               'kZYX': ''},
                                                 'values': "Enum('RotationOrder', {'kXYZ': 0, 'kYZX': 1, 'kZXY': 2, 'kXZY': 3, 'kYXZ': 4, 'kZYX': 5})"}},
                     'methods': {'__add__': [{'argInfo': {'other': {'doc': 'the euler rotation to be added to this euler rotation',
                                                                    'type': 'MEulerRotation'}},
                                              'args': [('other',
                                                        'MEulerRotation',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThe euler rotation addition operator.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The sum of the two euler rotations ',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&']},
                                              'types': {'other': 'MEulerRotation'}}],
                                 '__eq__': [{'argInfo': {'other': {'doc': 'the euler rotation to be compared with this euler rotation',
                                                                   'type': 'MEulerRotation'}},
                                             'args': [('other',
                                                       'MEulerRotation',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe euler rotation equality operator.',
                                             'inArgs': ['other'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': ' true the euler rotations are identical  false the euler rotations are not identical   ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'other': ['const',
                                                                          '&']},
                                             'types': {'other': 'MEulerRotation'}}],
                                 '__getitem__': [{'argInfo': {'i': {'doc': 'value indicating which component to return',
                                                                    'type': 'uint'}},
                                                  'args': [('i',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThe index operator. If its argument is 0 it will return the x component of the euler rotation. If its argument is 1 it will return the y component of the euler rotation. If its argument is 2 it will return the z component of the euler rotation.',
                                                  'inArgs': ['i'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The component of the euler rotation corresponding to the index ',
                                                                 'qualifiers': [],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'i': ['unsigned']},
                                                  'types': {'i': 'uint'}},
                                                 {'argInfo': {'i': {'doc': 'value indicating which component to return',
                                                                    'type': 'uint'}},
                                                  'args': [('i',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                  'inArgs': ['i'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'A reference to the component of the euler rotation corresponding to the index ',
                                                                 'qualifiers': ['&'],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'i': ['unsigned']},
                                                  'types': {'i': 'uint'}}],
                                 '__iadd__': [{'argInfo': {'other': {'doc': 'the euler rotation to be added with this euler rotation',
                                                                     'type': 'MEulerRotation'}},
                                               'args': [('other',
                                                         'MEulerRotation',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThe in place euler rotation addition operator.',
                                               'inArgs': ['other'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference the euler rotation which has been added to the other euler rotation ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {'other': ['const',
                                                                            '&']},
                                               'types': {'other': 'MEulerRotation'}}],
                                 '__imul__': [{'argInfo': {'other': {'doc': 'the euler rotation to be multiplied with this euler rotation',
                                                                     'type': 'MEulerRotation'}},
                                               'args': [('other',
                                                         'MEulerRotation',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThe in place euler rotation multiplication operator.',
                                               'inArgs': ['other'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the euler rotation which has been multiplied with the other euler rotation ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {'other': ['const',
                                                                            '&']},
                                               'types': {'other': 'MEulerRotation'}},
                                              {'argInfo': {'other': {'doc': 'the quaternion to be multiplied with this euler rotation',
                                                                     'type': 'MQuaternion'}},
                                               'args': [('other',
                                                         'MQuaternion',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThe in place quaternion multiplication operator.',
                                               'inArgs': ['other'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the euler rotation which has been multiplied with the quaternion ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {'other': ['const',
                                                                            '&']},
                                               'types': {'other': 'MQuaternion'}},
                                              {'argInfo': {'other': {'doc': 'the double to be multiplied with this euler rotation',
                                                                     'type': 'double'}},
                                               'args': [('other',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThe in place scalar multiplication operator.',
                                               'inArgs': ['other'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the euler rotation which has been multiplied with the double ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {'other': []},
                                               'types': {'other': 'double'}}],
                                 '__isub__': [{'argInfo': {'other': {'doc': 'the euler rotation to be subtracted from this euler rotation',
                                                                     'type': 'MEulerRotation'}},
                                               'args': [('other',
                                                         'MEulerRotation',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThe in place euler rotation subtraction operator.',
                                               'inArgs': ['other'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference the euler rotation which has had the other euler rotation subtracted from it ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {'other': ['const',
                                                                            '&']},
                                               'types': {'other': 'MEulerRotation'}}],
                                 '__mul__': [{'argInfo': {'other': {'doc': 'the euler rotation to be multiplied with this euler rotation',
                                                                    'type': 'MEulerRotation'}},
                                              'args': [('other',
                                                        'MEulerRotation',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThe euler rotation multiplication operator.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The product of the two euler rotations ',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&']},
                                              'types': {'other': 'MEulerRotation'}},
                                             {'argInfo': {'other': {'doc': 'the quaternion to be multiplied with this euler rotation',
                                                                    'type': 'MQuaternion'}},
                                              'args': [('other',
                                                        'MQuaternion',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis quaternion multiplication operator.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The product of the euler rotation and the quaternion ',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&']},
                                              'types': {'other': 'MQuaternion'}},
                                             {'argInfo': {'other': {'doc': 'the scalar value to be multiplied with this euler rotation',
                                                                    'type': 'double'}},
                                              'args': [('other',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis scalar multiplication operator.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The product of the euler rotation and the scalar value ',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {'other': []},
                                              'types': {'other': 'double'}},
                                             {'argInfo': {'other': {'doc': 'the euler rotation to which the scale should be applied',
                                                                    'type': 'MEulerRotation'},
                                                          'scale': {'doc': 'the amount by which the euler rotation should be scaled ',
                                                                    'type': 'double'}},
                                              'args': [('scale',
                                                        'double',
                                                        'in'),
                                                       ('other',
                                                        'MEulerRotation',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['scale',
                                                         'other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Euler rotation that is the result of scaling the other euler rotation ',
                                                             'qualifiers': ['MEulerRotation'],
                                                             'type': ('MEulerRotation',
                                                                      'OPENMAYA_EXPORT')},
                                              'returnType': ('MEulerRotation',
                                                             'OPENMAYA_EXPORT'),
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&'],
                                                                 'scale': []},
                                              'types': {'other': 'MEulerRotation',
                                                        'scale': 'double'}}],
                                 '__ne__': [{'argInfo': {'other': {'doc': 'the euler rotation to be compared with this euler rotation',
                                                                   'type': 'MEulerRotation'}},
                                             'args': [('other',
                                                       'MEulerRotation',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe euler rotation inequality operator.',
                                             'inArgs': ['other'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': ' true the euler rotations are not identical  false the euler rotations are identical   ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'other': ['const',
                                                                          '&']},
                                             'types': {'other': 'MEulerRotation'}}],
                                 '__sub__': [{'argInfo': {'other': {'doc': 'the euler rotation to be subtracted from this euler rotation',
                                                                    'type': 'MEulerRotation'}},
                                              'args': [('other',
                                                        'MEulerRotation',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThe euler rotation subtraction operator.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The euler rotation that results from the subtraction ',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&']},
                                              'types': {'other': 'MEulerRotation'}},
                                             {'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThe unary minus operator. Negates the value of each of the x, y, and z components of the euler rotation. The order remains the same.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'alternateSolution': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns an alternate solution to this rotation. The resulting rotation will be bound between +/- PI, and the rotation order will remain unchanged.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'MEulerRotation'},
                                                        'returnType': 'MEulerRotation',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}},
                                                       {'argInfo': {'src': {'doc': 'the rotation to compute an alternate solution to',
                                                                            'type': 'MEulerRotation'}},
                                                        'args': [('src',
                                                                  'MEulerRotation',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                        'inArgs': ['src'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The alternate solution to the input rotation ',
                                                                       'qualifiers': [],
                                                                       'type': 'MEulerRotation'},
                                                        'returnType': 'MEulerRotation',
                                                        'static': True,
                                                        'typeQualifiers': {'src': ['const',
                                                                                   '&']},
                                                        'types': {'src': 'MEulerRotation'}}],
                                 'asMatrix': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nConverts an euler rotation to a rotation matrix.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MMatrix'},
                                               'returnType': 'MMatrix',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'asQuaternion': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nConverts an euler rotation to a quaternion.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MQuaternion'},
                                                   'returnType': 'MQuaternion',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'asVector': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nConverts an euler rotation to a vector. The rotation order component is dropped.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MVector'},
                                               'returnType': 'MVector',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'bound': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the result of bounding this rotation to be within +/- PI. Bounding a rotation to be within +/- PI is defined to be the result of offsetting the rotation by +/- 2nPI (term by term) such that the offset is within +/- PI.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MEulerRotation'},
                                            'returnType': 'MEulerRotation',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}},
                                           {'argInfo': {'src': {'doc': 'the input rotation',
                                                                'type': 'MEulerRotation'}},
                                            'args': [('src',
                                                      'MEulerRotation',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['src'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The euler rotation that bounds the input rotation ',
                                                           'qualifiers': [],
                                                           'type': 'MEulerRotation'},
                                            'returnType': 'MEulerRotation',
                                            'static': True,
                                            'typeQualifiers': {'src': ['const',
                                                                       '&']},
                                            'types': {'src': 'MEulerRotation'}}],
                                 'boundIt': [{'argInfo': {'src': {'doc': 'the input rotation that will be bound',
                                                                  'type': 'MEulerRotation'}},
                                              'args': [('src',
                                                        'MEulerRotation',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets this euler rotation to be the input rotation that has been bound to be within +/- PI. Bounding a rotation to be within +/- PI is defined to be the result of offsetting the rotation by +/- 2nPI (term by term) such that the offset is within +/- PI.',
                                              'inArgs': ['src'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A reference to the euler rotation that has been set to the bound input rotation ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {'src': ['const',
                                                                         '&']},
                                              'types': {'src': 'MEulerRotation'}},
                                             {'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nBounds this rotation to be within +/- PI. Bounding a rotation to be within +/- PI is defined to be the result of offsetting the rotation by +/- 2nPI (term by term) such that the offset is within +/- PI.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['&'],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'closestCut': [{'argInfo': {'dst': {'doc': 'the range of the closest cut',
                                                                     'type': 'MEulerRotation'}},
                                                 'args': [('dst',
                                                           'MEulerRotation',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the closest cut of this rotation to "dst". The closest cut of rotation A to rotation B is defined to be the rotation that is +/- 2nPI to rotation A (term by term) and within +/- PI to rotation B.',
                                                 'inArgs': ['dst'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The closest cut of this rotation ',
                                                                'qualifiers': [],
                                                                'type': 'MEulerRotation'},
                                                 'returnType': 'MEulerRotation',
                                                 'static': False,
                                                 'typeQualifiers': {'dst': ['const',
                                                                            '&']},
                                                 'types': {'dst': 'MEulerRotation'}},
                                                {'argInfo': {'dst': {'doc': 'the range of the closest cut',
                                                                     'type': 'MEulerRotation'},
                                                             'src': {'doc': 'the euler rotation whose terms will be offset by +/- 2nPI ',
                                                                     'type': 'MEulerRotation'}},
                                                 'args': [('src',
                                                           'MEulerRotation',
                                                           'in'),
                                                          ('dst',
                                                           'MEulerRotation',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                 'inArgs': ['src', 'dst'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The closest cut of "src" to "dst" ',
                                                                'qualifiers': [],
                                                                'type': 'MEulerRotation'},
                                                 'returnType': 'MEulerRotation',
                                                 'static': True,
                                                 'typeQualifiers': {'dst': ['const',
                                                                            '&'],
                                                                    'src': ['const',
                                                                            '&']},
                                                 'types': {'dst': 'MEulerRotation',
                                                           'src': 'MEulerRotation'}}],
                                 'closestSolution': [{'argInfo': {'dst': {'doc': 'the euler rotation to which the solution should be closest',
                                                                          'type': 'MEulerRotation'}},
                                                      'args': [('dst',
                                                                'MEulerRotation',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the euler rotation that is the closest solution to the "dst" euler rotation.',
                                                      'inArgs': ['dst'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The closest solution to the "dst" rotation ',
                                                                     'qualifiers': [],
                                                                     'type': 'MEulerRotation'},
                                                      'returnType': 'MEulerRotation',
                                                      'static': False,
                                                      'typeQualifiers': {'dst': ['const',
                                                                                 '&']},
                                                      'types': {'dst': 'MEulerRotation'}},
                                                     {'argInfo': {'dst': {'doc': 'the euler rotation to which the solution should be closest',
                                                                          'type': 'MEulerRotation'},
                                                                  'src': {'doc': 'the euler rotation whose closest solution will be calculated ',
                                                                          'type': 'MEulerRotation'}},
                                                      'args': [('src',
                                                                'MEulerRotation',
                                                                'in'),
                                                               ('dst',
                                                                'MEulerRotation',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                      'inArgs': ['src',
                                                                 'dst'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The closest solution of "src" to "dst" ',
                                                                     'qualifiers': [],
                                                                     'type': 'MEulerRotation'},
                                                      'returnType': 'MEulerRotation',
                                                      'static': True,
                                                      'typeQualifiers': {'dst': ['const',
                                                                                 '&'],
                                                                         'src': ['const',
                                                                                 '&']},
                                                      'types': {'dst': 'MEulerRotation',
                                                                'src': 'MEulerRotation'}}],
                                 'decompose': [{'argInfo': {'matrix': {'doc': 'the matrix that will be decomposed into an euler rotation with the specified order ',
                                                                       'type': 'MMatrix'},
                                                            'ord': {'doc': 'the order which the euler rotation will have',
                                                                    'type': ('MEulerRotation',
                                                                             'RotationOrder')}},
                                                'args': [('matrix',
                                                          'MMatrix',
                                                          'in'),
                                                         ('ord',
                                                          ('MEulerRotation',
                                                           'RotationOrder'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDecompose a rotation matrix into the desired euler angles with the specified order.',
                                                'inArgs': ['matrix',
                                                           'ord'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The euler rotation that has been decomposed from the rotation matrix ',
                                                               'qualifiers': [],
                                                               'type': 'MEulerRotation'},
                                                'returnType': 'MEulerRotation',
                                                'static': True,
                                                'typeQualifiers': {'matrix': ['const',
                                                                              '&'],
                                                                   'ord': []},
                                                'types': {'matrix': 'MMatrix',
                                                          'ord': ('MEulerRotation',
                                                                  'RotationOrder')}}],
                                 'incrementalRotateBy': [{'argInfo': {'angle': {'doc': 'the angle by which to rotate around the axis',
                                                                                'type': 'double'},
                                                                      'axis': {'doc': 'the axis to rotate around ',
                                                                               'type': 'MVector'}},
                                                          'args': [('axis',
                                                                    'MVector',
                                                                    'in'),
                                                                   ('angle',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nPerform an incremental rotation by the specified axis and angle. The rotation is broken down and performed in smaller steps so that the angles update properly.',
                                                          'inArgs': ['axis',
                                                                     'angle'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'A reference to the euler rotation that has been incrementally rotated ',
                                                                         'qualifiers': ['&'],
                                                                         'type': 'MEulerRotation'},
                                                          'returnType': 'MEulerRotation',
                                                          'static': False,
                                                          'typeQualifiers': {'angle': [],
                                                                             'axis': ['const',
                                                                                      '&']},
                                                          'types': {'angle': 'double',
                                                                    'axis': 'MVector'}}],
                                 'inverse': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the inverse of this euler rotation. The rotation order will be reversed.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'invertIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nPerforms an in place inversion of this euler rotation. The rotation order will be reversed.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'isEquivalent': [{'argInfo': {'other': {'doc': 'the euler rotation to be compared with this euler rotation ',
                                                                         'type': 'MEulerRotation'},
                                                               'tolerance': {'doc': 'the amount of variation allowed for equivalency',
                                                                             'type': 'double'}},
                                                   'args': [('other',
                                                             'MEulerRotation',
                                                             'in'),
                                                            ('tolerance',
                                                             'double',
                                                             'in')],
                                                   'defaults': {'tolerance': 1e-10},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method returns true if this euler rotation is equivalent, within some given tolerance, to the other euler rotation.',
                                                   'inArgs': ['other',
                                                              'tolerance'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true the euler rotations are equivalent  false the euler rotations are not equivalent   ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'other': ['const',
                                                                                '&'],
                                                                      'tolerance': []},
                                                   'types': {'other': 'MEulerRotation',
                                                             'tolerance': 'double'}}],
                                 'isZero': [{'argInfo': {'tolerance': {'doc': 'the amount of variation allowed for equivalency to zero',
                                                                       'type': 'double'}},
                                             'args': [('tolerance',
                                                       'double',
                                                       'in')],
                                             'defaults': {'tolerance': 1e-10},
                                             'deprecated': False,
                                             'doc': '\r\nThis method returns true if this euler rotation is zero, within some given tolerance.',
                                             'inArgs': ['tolerance'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': ' true the rotation is zero  false the rotation is not zero   ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'tolerance': []},
                                             'types': {'tolerance': 'double'}}],
                                 'reorder': [{'argInfo': {'ord': {'doc': 'the new rotation order of the euler rotation',
                                                                  'type': ('MEulerRotation',
                                                                           'RotationOrder')}},
                                              'args': [('ord',
                                                        ('MEulerRotation',
                                                         'RotationOrder'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the reordering of this euler rotation, such that the euler rotation will have the specified rotation order.',
                                              'inArgs': ['ord'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Euler rotation that is the reordering of this euler rotation ',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {'ord': []},
                                              'types': {'ord': ('MEulerRotation',
                                                                'RotationOrder')}}],
                                 'reorderIt': [{'argInfo': {'ord': {'doc': 'the new rotation order of the euler rotation',
                                                                    'type': ('MEulerRotation',
                                                                             'RotationOrder')}},
                                                'args': [('ord',
                                                          ('MEulerRotation',
                                                           'RotationOrder'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nPerforms an in place reordering of this euler rotation, such that the euler rotation will have the specified rotation order.',
                                                'inArgs': ['ord'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the euler rotation that has been reordered ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MEulerRotation'},
                                                'returnType': 'MEulerRotation',
                                                'static': False,
                                                'typeQualifiers': {'ord': []},
                                                'types': {'ord': ('MEulerRotation',
                                                                  'RotationOrder')}}],
                                 'setToAlternateSolution': [{'argInfo': {'src': {'doc': 'the rotation to compute an alternate solution to',
                                                                                 'type': 'MEulerRotation'}},
                                                             'args': [('src',
                                                                       'MEulerRotation',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSets this euler rotation to an alternate solution of the input rotation. The resulting rotation will be bound between +/- PI, and the rotation order will remain unchanged.',
                                                             'inArgs': ['src'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'A reference to the euler rotation that has been set to an alternate solution ',
                                                                            'qualifiers': ['&'],
                                                                            'type': 'MEulerRotation'},
                                                             'returnType': 'MEulerRotation',
                                                             'static': False,
                                                             'typeQualifiers': {'src': ['const',
                                                                                        '&']},
                                                             'types': {'src': 'MEulerRotation'}},
                                                            {'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSets this euler rotation to an alternate solution of this rotation. The resulting rotation will be bound between +/- PI, and the rotation order will remain unchanged.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': ['&'],
                                                                            'type': 'MEulerRotation'},
                                                             'returnType': 'MEulerRotation',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                 'setToClosestCut': [{'argInfo': {'dst': {'doc': 'the range of the closest cut',
                                                                          'type': 'MEulerRotation'},
                                                                  'src': {'doc': 'the euler rotation whose terms will be offset by +/- 2nPI ',
                                                                          'type': 'MEulerRotation'}},
                                                      'args': [('src',
                                                                'MEulerRotation',
                                                                'in'),
                                                               ('dst',
                                                                'MEulerRotation',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets this rotation to be the closest cut of "src" to "dst". The closest cut of rotation A to rotation B is defined to be the rotation that is +/- 2nPI to rotation A (term by term) and within +/- PI to rotation B.',
                                                      'inArgs': ['src',
                                                                 'dst'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A reference to the euler rotation that has been set to the closest cut ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MEulerRotation'},
                                                      'returnType': 'MEulerRotation',
                                                      'static': False,
                                                      'typeQualifiers': {'dst': ['const',
                                                                                 '&'],
                                                                         'src': ['const',
                                                                                 '&']},
                                                      'types': {'dst': 'MEulerRotation',
                                                                'src': 'MEulerRotation'}},
                                                     {'argInfo': {'dst': {'doc': 'the range of the closest cut',
                                                                          'type': 'MEulerRotation'}},
                                                      'args': [('dst',
                                                                'MEulerRotation',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets this rotation to be the closest cut to "dst". The closest cut of rotation A to rotation B is defined to be the rotation that is +/- 2nPI to rotation A (term by term) and within +/- PI to rotation B.',
                                                      'inArgs': ['dst'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A reference to the euler rotation that has been set to the closest cut ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MEulerRotation'},
                                                      'returnType': 'MEulerRotation',
                                                      'static': False,
                                                      'typeQualifiers': {'dst': ['const',
                                                                                 '&']},
                                                      'types': {'dst': 'MEulerRotation'}}],
                                 'setToClosestSolution': [{'argInfo': {'dst': {'doc': 'the euler rotation to which the solution should be closest',
                                                                               'type': 'MEulerRotation'},
                                                                       'src': {'doc': 'the euler rotation whose closest solution will be calculated ',
                                                                               'type': 'MEulerRotation'}},
                                                           'args': [('src',
                                                                     'MEulerRotation',
                                                                     'in'),
                                                                    ('dst',
                                                                     'MEulerRotation',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSets this euler rotation to the euler rotation that is the closest solution of the "src" euler rotation to the "dst" euler rotation.',
                                                           'inArgs': ['src',
                                                                      'dst'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'A reference to the euler rotation that has been set to the closest solution ',
                                                                          'qualifiers': ['&'],
                                                                          'type': 'MEulerRotation'},
                                                           'returnType': 'MEulerRotation',
                                                           'static': False,
                                                           'typeQualifiers': {'dst': ['const',
                                                                                      '&'],
                                                                              'src': ['const',
                                                                                      '&']},
                                                           'types': {'dst': 'MEulerRotation',
                                                                     'src': 'MEulerRotation'}},
                                                          {'argInfo': {'dst': {'doc': 'the euler rotation to which the solution should be closest',
                                                                               'type': 'MEulerRotation'}},
                                                           'args': [('dst',
                                                                     'MEulerRotation',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSets this euler rotation to the euler rotation that is the closest solution to the "dst" euler rotation.',
                                                           'inArgs': ['dst'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'A reference to the euler rotation that has been set to the closest solution ',
                                                                          'qualifiers': ['&'],
                                                                          'type': 'MEulerRotation'},
                                                           'returnType': 'MEulerRotation',
                                                           'static': False,
                                                           'typeQualifiers': {'dst': ['const',
                                                                                      '&']},
                                                           'types': {'dst': 'MEulerRotation'}}],
                                 'setValue': [{'argInfo': {'ord': {'doc': 'the rotation order; the default rotation order is XYZ',
                                                                   'type': ('MEulerRotation',
                                                                            'RotationOrder')},
                                                           'v': {'doc': 'vector from which to set the x, y, and z rotation components ',
                                                                 'type': 'MVector'}},
                                               'args': [('v',
                                                         'MVector',
                                                         'in'),
                                                        ('ord',
                                                         ('MEulerRotation',
                                                          'RotationOrder'),
                                                         'in')],
                                               'defaults': {'ord': ('MEulerRotation',
                                                                    'RotationOrder',
                                                                    'kXYZ')},
                                               'deprecated': False,
                                               'doc': '\r\nSets the euler rotation to the values contained in the vector and with the specified rotation order.',
                                               'inArgs': ['v', 'ord'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the euler rotation whose value has been set ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {'ord': [],
                                                                  'v': ['const',
                                                                        '&']},
                                               'types': {'ord': ('MEulerRotation',
                                                                 'RotationOrder'),
                                                         'v': 'MVector'}},
                                              {'argInfo': {'ord': {'doc': 'the rotation order; the default rotation order is XYZ',
                                                                   'type': ('MEulerRotation',
                                                                            'RotationOrder')},
                                                           'xx': {'doc': 'the x component of the rotation ',
                                                                  'type': 'double'},
                                                           'yy': {'doc': 'the y component of the rotation ',
                                                                  'type': 'double'},
                                                           'zz': {'doc': 'the z component of the rotation ',
                                                                  'type': 'double'}},
                                               'args': [('xx',
                                                         'double',
                                                         'in'),
                                                        ('yy',
                                                         'double',
                                                         'in'),
                                                        ('zz',
                                                         'double',
                                                         'in'),
                                                        ('ord',
                                                         ('MEulerRotation',
                                                          'RotationOrder'),
                                                         'in')],
                                               'defaults': {'ord': ('MEulerRotation',
                                                                    'RotationOrder',
                                                                    'kXYZ')},
                                               'deprecated': False,
                                               'doc': '\r\nSets the euler rotation to the x, y, and z rotation components with the specified rotation order.',
                                               'inArgs': ['xx',
                                                          'yy',
                                                          'zz',
                                                          'ord'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the euler rotation whose value has been set ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MEulerRotation'},
                                               'returnType': 'MEulerRotation',
                                               'static': False,
                                               'typeQualifiers': {'ord': [],
                                                                  'xx': [],
                                                                  'yy': [],
                                                                  'zz': []},
                                               'types': {'ord': ('MEulerRotation',
                                                                 'RotationOrder'),
                                                         'xx': 'double',
                                                         'yy': 'double',
                                                         'zz': 'double'}}]},
                     'pymelEnums': {'RotationOrder': "Enum('RotationOrder', [('XYZ', 0), ('kXYZ', 0), ('YZX', 1), ('kYZX', 1), ('ZXY', 2), ('kZXY', 2), ('XZY', 3), ('kXZY', 3), ('YXZ', 4), ('kYXZ', 4), ('ZYX', 5), ('kZYX', 5)], multiKeys=True)"}},
  'MEvaluationManager': {'enums': {},
                         'methods': {'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'evaluationInExecution': [{'argInfo': {'context': {'doc': 'Evaluation context for status test.',
                                                                                        'type': 'MDGContext'}},
                                                                'args': [('context',
                                                                          'MDGContext',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nDetermine if the evaluation manager is currently evaluating given context.',
                                                                'inArgs': ['context'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'True if the evaluation manager is evaluating given context, otherwise false. ',
                                                                               'qualifiers': [],
                                                                               'type': 'bool'},
                                                                'returnType': 'bool',
                                                                'static': True,
                                                                'typeQualifiers': {'context': ['const',
                                                                                               '&']},
                                                                'types': {'context': 'MDGContext'}}],
                                     'evaluationManagerActive': [{'argInfo': {'context': {'doc': 'Evaluation context for status test.',
                                                                                          'type': 'MDGContext'}},
                                                                  'args': [('context',
                                                                            'MDGContext',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nDetermine if the evaluation manager is active on given context.',
                                                                  'inArgs': ['context'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'True if the evaluation manager is active on the given context, otherwise false. ',
                                                                                 'qualifiers': [],
                                                                                 'type': 'bool'},
                                                                  'returnType': 'bool',
                                                                  'static': True,
                                                                  'typeQualifiers': {'context': ['const',
                                                                                                 '&']},
                                                                  'types': {'context': 'MDGContext'}}],
                                     'graphConstructionActive': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nDetermine if the evaluation graph is currently being constructed.',
                                                                  'inArgs': [],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'True if the evaluation graph is being constructed, otherwise false. ',
                                                                                 'qualifiers': [],
                                                                                 'type': 'bool'},
                                                                  'returnType': 'bool',
                                                                  'static': True,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}]},
                         'pymelEnums': {}},
  'MEvaluationNode': {'enums': {},
                      'methods': {'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'datablock': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the datablock for this node',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The MDatablock representing the datablock for this evaluation node.',
                                                                'qualifiers': [],
                                                                'type': 'MDataBlock'},
                                                 'returnType': 'MDataBlock',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                  'dependencyNode': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the dependency node this evaluation node represents.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The MObject representing the dependency node for this evaluation node.',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                  'dirtyPlug': [{'argInfo': {'attribute': {'doc': 'Attribute whose root plug is returned if it is in the dirty plug list ',
                                                                           'type': 'MObject'}},
                                                 'args': [('attribute',
                                                           'MObject',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the top-most plug for the specified attribute if the attribute has dirty plugs. This call should be made from  MPxNode::preEvaluation()  and  MPxNode::postEvaluation()  to access a networked plug which is going to be dirty and computed.',
                                                 'inArgs': ['attribute'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The top-most dirty plug for the specified attribute if it exists, a null plug otherwise.',
                                                                'qualifiers': [],
                                                                'type': 'MPlug'},
                                                 'returnType': 'MPlug',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'attribute': ['const',
                                                                                  '&']},
                                                 'types': {'attribute': 'MObject'}}],
                                  'dirtyPlugExists': [{'argInfo': {'attribute': {'doc': 'Attribute whose root plug is to be checked for membership in the dirty plug list ',
                                                                                 'type': 'MObject'}},
                                                       'args': [('attribute',
                                                                 'MObject',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns true if the specified attribute has a dirty plug. This call should be made from  MPxNode::preEvaluation()  and  MPxNode::postEvaluation()  to verify which plugs are going to be dirty and computed.',
                                                       'inArgs': ['attribute'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'True if the attribute exists in the dirty plug list, otherwise false.',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'attribute': ['const',
                                                                                        '&']},
                                                       'types': {'attribute': 'MObject'}}],
                                  'iterator': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns an iterator at the beginning of the dirty plug list.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': "Iterator positioned at the beginning of the evaluation node's dirty plug list",
                                                               'qualifiers': [],
                                                               'type': 'MEvaluationNodeIterator'},
                                                'returnType': 'MEvaluationNodeIterator',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}]},
                      'pymelEnums': {}},
  'MEvaluationNodeIterator': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the name of this class.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'isDone': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nChecks to see if the iterator has reached the end of the iteration',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                          'next': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nAdvances the iterator to the next position in the dirty plug list \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                          'plug': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the dirty plug at the current iterator position. Returns an empty plug if the iterator is illegal.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'MPlug'},
                                                    'returnType': 'MPlug',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                          'reset': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nResets the iterator to the first position in the dirty plug list \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}]},
                              'pymelEnums': {}},
  'MEvent': {'enums': {'ModifierType': {'valueDocs': {'controlKey': '',
                                                      'shiftKey': ''},
                                        'values': "Enum('ModifierType', {'shiftKey': 1, 'controlKey': 4})"},
                       'MouseButtonType': {'valueDocs': {'kLeftMouse': '',
                                                         'kMiddleMouse': '',
                                                         'leftMouse': '',
                                                         'middleMouse': ''},
                                           'values': "Enum('MouseButtonType', {'kLeftMouse': 64, 'kMiddleMouse': 128})"}},
             'invertibles': [('setModifiers', 'modifiers'),
                             ('setPosition', 'getPosition')],
             'methods': {'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['*'],
                                                       'type': 'char'},
                                        'returnType': 'char',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'getPosition': [{'argInfo': {'x_pos': {'doc': 'storage for horizonal position ',
                                                                'type': 'short'},
                                                      'y_pos': {'doc': 'storage for vertical position',
                                                                'type': 'short'}},
                                          'args': [('x_pos',
                                                    'short',
                                                    'out'),
                                                   ('y_pos',
                                                    'short',
                                                    'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGet the location of the event in view co-ordinates. The origin is at the lower left corner of the window.',
                                          'inArgs': [],
                                          'inverse': ('setPosition',
                                                      False),
                                          'outArgs': ['x_pos', 'y_pos'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'x_pos': ['&'],
                                                             'y_pos': ['&']},
                                          'types': {'x_pos': 'short',
                                                    'y_pos': 'short'}}],
                         'getWindowPosition': [{'argInfo': {'x_pos': {'doc': 'storage for horizonal position ',
                                                                      'type': 'short'},
                                                            'y_pos': {'doc': 'storage for vertical position',
                                                                      'type': 'short'}},
                                                'args': [('x_pos',
                                                          'short',
                                                          'out'),
                                                         ('y_pos',
                                                          'short',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis routine is used by responders to query the position of the pointer when the event occurred. It is given in screen co-ordinates.',
                                                'inArgs': [],
                                                'outArgs': ['x_pos',
                                                            'y_pos'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'x_pos': ['&'],
                                                                   'y_pos': ['&']},
                                                'types': {'x_pos': 'short',
                                                          'y_pos': 'short'}}],
                         'isModifierControl': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nreturn state of control key.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' true Control key triggered this event.  false The control key did not cause this event.  ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                         'isModifierKeyRelease': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nWas a modifier key released.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true A modifier key was released.  false No modifier key was released.  ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                         'isModifierLeftMouseButton': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturn the state of the left mouse button.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': ' true Left mouse button triggered this event.  false The left moust button did not cause this event.  ',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                         'isModifierMiddleMouseButton': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturn the state of the middle mouse button.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': ' true Middle mouse button triggered this event.  false The middle moust button did not cause this event.  ',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                         'isModifierNone': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines if there are any modifiers for this event.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': ' true There are modifiers for this event.  false There are NO modifiers for this event.  ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                         'isModifierShift': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nreturn state of shift key.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': ' true Shift key triggered this event.  false The shift key did not cause this event.  ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                         'modifiers': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThis routine is used by responders to find the state of the modifiers during the event.',
                                        'inArgs': [],
                                        'inverse': ('setModifiers',
                                                    False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'Modifier type.',
                                                       'qualifiers': [],
                                                       'type': ('MEvent',
                                                                'ModifierType')},
                                        'returnType': ('MEvent',
                                                       'ModifierType'),
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                         'mouseButton': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGet the mouse button of the last event.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Mouse button from last event.',
                                                         'qualifiers': [],
                                                         'type': ('MEvent',
                                                                  'MouseButtonType')},
                                          'returnType': ('MEvent',
                                                         'MouseButtonType'),
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                         'setModifiers': [{'argInfo': {'modType': {'doc': 'Type of modifier to set to.',
                                                                   'type': ('MEvent',
                                                                            'ModifierType')}},
                                           'args': [('modType',
                                                     ('MEvent',
                                                      'ModifierType'),
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nset the event modifiers.',
                                           'inArgs': ['modType'],
                                           'inverse': ('modifiers', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'modType': ['const',
                                                                          '&']},
                                           'types': {'modType': ('MEvent',
                                                                 'ModifierType')}}],
                         'setPosition': [{'argInfo': {'x_pos': {'doc': 'horizonal position to set ',
                                                                'type': 'short'},
                                                      'y_pos': {'doc': 'vertical position to set',
                                                                'type': 'short'}},
                                          'args': [('x_pos',
                                                    'short',
                                                    'in'),
                                                   ('y_pos',
                                                    'short',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nset the location of the event to the specified location. The origin is at the lower left corner of the window.',
                                          'inArgs': ['x_pos', 'y_pos'],
                                          'inverse': ('getPosition',
                                                      True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'x_pos': [],
                                                             'y_pos': []},
                                          'types': {'x_pos': 'short',
                                                    'y_pos': 'short'}}]},
             'pymelEnums': {'ModifierType': "Enum('ModifierType', {'shiftKey': 1, 'controlKey': 4})",
                            'MouseButtonType': "Enum('MouseButtonType', [('leftMouse', 64), ('kLeftMouse', 64), ('middleMouse', 128), ('kMiddleMouse', 128)], multiKeys=True)"},
             'pymelMethods': {'modifiers': 'getModifiers'}},
  'MEventMessage': {'enums': {},
                    'methods': {'addEventCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                 'type': 'void'},
                                                                  'eventName': {'doc': 'the event to register the callback for ',
                                                                                'type': 'MString'},
                                                                  'func': {'doc': 'the callback function',
                                                                           'type': ('MMessage',
                                                                                    'MBasicFunction')}},
                                                      'args': [('eventName',
                                                                'MString',
                                                                'in'),
                                                               ('func',
                                                                ('MMessage',
                                                                 'MBasicFunction'),
                                                                'in'),
                                                               ('clientData',
                                                                'void',
                                                                'in')],
                                                      'defaults': {'clientData': None},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method registers a callback for event occurred messages.',
                                                      'inArgs': ['eventName',
                                                                 'func',
                                                                 'clientData'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                     'qualifiers': [],
                                                                     'type': 'MCallbackId'},
                                                      'returnType': 'MCallbackId',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'clientData': ['*'],
                                                                         'eventName': ['const',
                                                                                       '&'],
                                                                         'func': []},
                                                      'types': {'clientData': 'void',
                                                                'eventName': 'MString',
                                                                'func': ('MMessage',
                                                                         'MBasicFunction')}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'getEventNames': [{'argInfo': {'names': {'doc': 'set to the array of available event names.',
                                                                         'type': 'MStringArray'}},
                                                   'args': [('names',
                                                             'MStringArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method returns the list of available event names.',
                                                   'inArgs': [],
                                                   'outArgs': ['names'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'names': ['&']},
                                                   'types': {'names': 'MStringArray'}}]},
                    'pymelEnums': {}},
  'MExternalContentInfoTable': {'enums': {},
                                'methods': {'addResolvedEntry': [{'argInfo': {'key': {'doc': "An arbitrary string defined by the caller. This will typically be an attribute name for situations where the content location is stored verbatim in a plug's value.",
                                                                                      'type': 'MString'},
                                                                              'resolvedLocation': {'doc': 'Full path to the content if it exists at the time of creation of this object.',
                                                                                                   'type': 'MString'},
                                                                              'roles': {'doc': 'An enumeration of all roles this content plays in the context of the node. The actual strings are not rigidly defined as of this writing. This is mostly for offline browsing of the content info: to assist in sorting content by role. A better content type system may be introduced later on to formalize this.',
                                                                                        'type': 'MStringArray'},
                                                                              'unresolvedLocation': {'doc': 'Path as stored in the node (i.e. without any token replacement performed).',
                                                                                                     'type': 'MString'}},
                                                                  'args': [('key',
                                                                            'MString',
                                                                            'in'),
                                                                           ('unresolvedLocation',
                                                                            'MString',
                                                                            'in'),
                                                                           ('resolvedLocation',
                                                                            'MString',
                                                                            'in'),
                                                                           ('roles',
                                                                            'MStringArray',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': True,
                                                                  'doc': '\n This method is obsolete. \n',
                                                                  'inArgs': ['key',
                                                                             'unresolvedLocation',
                                                                             'resolvedLocation',
                                                                             'roles'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'key': ['const',
                                                                                             '&'],
                                                                                     'resolvedLocation': ['const',
                                                                                                          '&'],
                                                                                     'roles': ['const',
                                                                                               '&'],
                                                                                     'unresolvedLocation': ['const',
                                                                                                            '&']},
                                                                  'types': {'key': 'MString',
                                                                            'resolvedLocation': 'MString',
                                                                            'roles': 'MStringArray',
                                                                            'unresolvedLocation': 'MString'}},
                                                                 {'argInfo': {'contextNodeFullName': {'doc': 'The fullname of the URI owner (node) if it applies, an empty string otherwise.',
                                                                                                      'type': 'MString'},
                                                                              'key': {'doc': "An arbitrary string defined by the caller. This will typically be an attribute name for situations where the content location is stored verbatim in a plug's value.",
                                                                                      'type': 'MString'},
                                                                              'resolvedLocation': {'doc': 'Full path to the content if it exists at the time of creation of this object.',
                                                                                                   'type': 'MString'},
                                                                              'roles': {'doc': 'An enumeration of all roles this content plays in the context of the node. The actual strings are not rigidly defined as of this writing. This is mostly for offline browsing of the content info: to assist in sorting content by role. A better content type system may be introduced later on to formalize this.',
                                                                                        'type': 'MStringArray'},
                                                                              'unresolvedLocation': {'doc': 'Path as stored in the node (i.e. without any token replacement performed).',
                                                                                                     'type': 'MString'}},
                                                                  'args': [('key',
                                                                            'MString',
                                                                            'in'),
                                                                           ('unresolvedLocation',
                                                                            'MString',
                                                                            'in'),
                                                                           ('resolvedLocation',
                                                                            'MString',
                                                                            'in'),
                                                                           ('contextNodeFullName',
                                                                            'MString',
                                                                            'in'),
                                                                           ('roles',
                                                                            'MStringArray',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nAdd an entry in the table.',
                                                                  'inArgs': ['key',
                                                                             'unresolvedLocation',
                                                                             'resolvedLocation',
                                                                             'contextNodeFullName',
                                                                             'roles'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'contextNodeFullName': ['const',
                                                                                                             '&'],
                                                                                     'key': ['const',
                                                                                             '&'],
                                                                                     'resolvedLocation': ['const',
                                                                                                          '&'],
                                                                                     'roles': ['const',
                                                                                               '&'],
                                                                                     'unresolvedLocation': ['const',
                                                                                                            '&']},
                                                                  'types': {'contextNodeFullName': 'MString',
                                                                            'key': 'MString',
                                                                            'resolvedLocation': 'MString',
                                                                            'roles': 'MStringArray',
                                                                            'unresolvedLocation': 'MString'}}],
                                            'addUnresolvedEntry': [{'argInfo': {'key': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                        'type': 'MString'},
                                                                                'roles': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry.',
                                                                                          'type': 'MStringArray'},
                                                                                'unresolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                                       'type': 'MString'}},
                                                                    'args': [('key',
                                                                              'MString',
                                                                              'in'),
                                                                             ('unresolvedLocation',
                                                                              'MString',
                                                                              'in'),
                                                                             ('roles',
                                                                              'MStringArray',
                                                                              'in')],
                                                                    'defaults': {'roles': 'MStringArray()'},
                                                                    'deprecated': True,
                                                                    'doc': '\n This method is obsolete. \n',
                                                                    'inArgs': ['key',
                                                                               'unresolvedLocation',
                                                                               'roles'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'key': ['const',
                                                                                               '&'],
                                                                                       'roles': ['const',
                                                                                                 '&'],
                                                                                       'unresolvedLocation': ['const',
                                                                                                              '&']},
                                                                    'types': {'key': 'MString',
                                                                              'roles': 'MStringArray',
                                                                              'unresolvedLocation': 'MString'}},
                                                                   {'argInfo': {'contextNodeFullName': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                                        'type': 'MString'},
                                                                                'key': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                        'type': 'MString'},
                                                                                'roles': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry.',
                                                                                          'type': 'MStringArray'},
                                                                                'unresolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                                       'type': 'MString'}},
                                                                    'args': [('key',
                                                                              'MString',
                                                                              'in'),
                                                                             ('unresolvedLocation',
                                                                              'MString',
                                                                              'in'),
                                                                             ('contextNodeFullName',
                                                                              'MString',
                                                                              'in'),
                                                                             ('roles',
                                                                              'MStringArray',
                                                                              'in')],
                                                                    'defaults': {'roles': 'MStringArray()'},
                                                                    'deprecated': False,
                                                                    'doc': "\nAdd an entry in the table. The resolved location will be inferred from the application's built-in file resolving for the specified file type. This will automatically add entries into the roles vector that correspond to the search rules for this file type.",
                                                                    'inArgs': ['key',
                                                                               'unresolvedLocation',
                                                                               'contextNodeFullName',
                                                                               'roles'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'contextNodeFullName': ['const',
                                                                                                               '&'],
                                                                                       'key': ['const',
                                                                                               '&'],
                                                                                       'roles': ['const',
                                                                                                 '&'],
                                                                                       'unresolvedLocation': ['const',
                                                                                                              '&']},
                                                                    'types': {'contextNodeFullName': 'MString',
                                                                              'key': 'MString',
                                                                              'roles': 'MStringArray',
                                                                              'unresolvedLocation': 'MString'}}],
                                            'getEntry': [{'argInfo': {'index': {'doc': 'Position of the entry to retrieve information from. ',
                                                                                'type': 'uint'},
                                                                      'key': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                              'type': 'MString'},
                                                                      'resolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                           'type': 'MString'},
                                                                      'roles': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry.',
                                                                                'type': 'MStringArray'},
                                                                      'unresolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                             'type': 'MString'}},
                                                          'args': [('index',
                                                                    'uint',
                                                                    'in'),
                                                                   ('key',
                                                                    'MString',
                                                                    'out'),
                                                                   ('unresolvedLocation',
                                                                    'MString',
                                                                    'out'),
                                                                   ('resolvedLocation',
                                                                    'MString',
                                                                    'out'),
                                                                   ('roles',
                                                                    'MStringArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': True,
                                                          'doc': '\n This method is obsolete. \n',
                                                          'inArgs': ['index'],
                                                          'outArgs': ['key',
                                                                      'unresolvedLocation',
                                                                      'resolvedLocation',
                                                                      'roles'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'index': ['unsigned'],
                                                                             'key': ['&'],
                                                                             'resolvedLocation': ['&'],
                                                                             'roles': ['&'],
                                                                             'unresolvedLocation': ['&']},
                                                          'types': {'index': 'uint',
                                                                    'key': 'MString',
                                                                    'resolvedLocation': 'MString',
                                                                    'roles': 'MStringArray',
                                                                    'unresolvedLocation': 'MString'}},
                                                         {'argInfo': {'contextNodeFullName': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                              'type': 'MString'},
                                                                      'index': {'doc': 'Position of the entry to retrieve information from. ',
                                                                                'type': 'uint'},
                                                                      'key': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                              'type': 'MString'},
                                                                      'resolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                           'type': 'MString'},
                                                                      'roles': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry.',
                                                                                'type': 'MStringArray'},
                                                                      'unresolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                             'type': 'MString'}},
                                                          'args': [('index',
                                                                    'uint',
                                                                    'in'),
                                                                   ('key',
                                                                    'MString',
                                                                    'out'),
                                                                   ('unresolvedLocation',
                                                                    'MString',
                                                                    'out'),
                                                                   ('resolvedLocation',
                                                                    'MString',
                                                                    'out'),
                                                                   ('contextNodeFullName',
                                                                    'MString',
                                                                    'out'),
                                                                   ('roles',
                                                                    'MStringArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nNO SCRIPT SUPPORT. \n',
                                                          'inArgs': ['index'],
                                                          'outArgs': ['key',
                                                                      'unresolvedLocation',
                                                                      'resolvedLocation',
                                                                      'contextNodeFullName',
                                                                      'roles'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'contextNodeFullName': ['&'],
                                                                             'index': ['unsigned'],
                                                                             'key': ['&'],
                                                                             'resolvedLocation': ['&'],
                                                                             'roles': ['&'],
                                                                             'unresolvedLocation': ['&']},
                                                          'types': {'contextNodeFullName': 'MString',
                                                                    'index': 'uint',
                                                                    'key': 'MString',
                                                                    'resolvedLocation': 'MString',
                                                                    'roles': 'MStringArray',
                                                                    'unresolvedLocation': 'MString'}}],
                                            'getInfo': [{'argInfo': {'key': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                             'type': 'MString'},
                                                                     'resolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                          'type': 'MString'},
                                                                     'roles': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry.',
                                                                               'type': 'MStringArray'},
                                                                     'unresolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                            'type': 'MString'}},
                                                         'args': [('key',
                                                                   'MString',
                                                                   'in'),
                                                                  ('unresolvedLocation',
                                                                   'MString',
                                                                   'out'),
                                                                  ('resolvedLocation',
                                                                   'MString',
                                                                   'out'),
                                                                  ('roles',
                                                                   'MStringArray',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': True,
                                                         'doc': '\n This method is obsolete. \n',
                                                         'inArgs': ['key'],
                                                         'outArgs': ['unresolvedLocation',
                                                                     'resolvedLocation',
                                                                     'roles'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'key': ['const',
                                                                                    '&'],
                                                                            'resolvedLocation': ['&'],
                                                                            'roles': ['&'],
                                                                            'unresolvedLocation': ['&']},
                                                         'types': {'key': 'MString',
                                                                   'resolvedLocation': 'MString',
                                                                   'roles': 'MStringArray',
                                                                   'unresolvedLocation': 'MString'}},
                                                        {'argInfo': {'contextNodeFullName': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                             'type': 'MString'},
                                                                     'key': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                             'type': 'MString'},
                                                                     'resolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                          'type': 'MString'},
                                                                     'roles': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry.',
                                                                               'type': 'MStringArray'},
                                                                     'unresolvedLocation': {'doc': 'See documentation for MExternalContentInfoTable::addResolvedEntry. ',
                                                                                            'type': 'MString'}},
                                                         'args': [('key',
                                                                   'MString',
                                                                   'in'),
                                                                  ('unresolvedLocation',
                                                                   'MString',
                                                                   'out'),
                                                                  ('resolvedLocation',
                                                                   'MString',
                                                                   'out'),
                                                                  ('contextNodeFullName',
                                                                   'MString',
                                                                   'out'),
                                                                  ('roles',
                                                                   'MStringArray',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nNO SCRIPT SUPPORT. \n',
                                                         'inArgs': ['key'],
                                                         'outArgs': ['unresolvedLocation',
                                                                     'resolvedLocation',
                                                                     'contextNodeFullName',
                                                                     'roles'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'contextNodeFullName': ['&'],
                                                                            'key': ['const',
                                                                                    '&'],
                                                                            'resolvedLocation': ['&'],
                                                                            'roles': ['&'],
                                                                            'unresolvedLocation': ['&']},
                                                         'types': {'contextNodeFullName': 'MString',
                                                                   'key': 'MString',
                                                                   'resolvedLocation': 'MString',
                                                                   'roles': 'MStringArray',
                                                                   'unresolvedLocation': 'MString'}}],
                                            'length': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieves the number of entries in the table.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}]},
                                'pymelEnums': {}},
  'MExternalContentLocationTable': {'enums': {},
                                    'methods': {'addEntry': [{'argInfo': {'key': {'doc': "An arbitrary string defined by the node. This will typically be an attribute name for situations where the content location is stored verbatim in a plug's value. ",
                                                                                  'type': 'MString'},
                                                                          'location': {'doc': 'Full path to the content referenced by the key.',
                                                                                       'type': 'MString'}},
                                                              'args': [('key',
                                                                        'MString',
                                                                        'in'),
                                                                       ('location',
                                                                        'MString',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nAdds an external content location and its key to the table.',
                                                              'inArgs': ['key',
                                                                         'location'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'key': ['const',
                                                                                         '&'],
                                                                                 'location': ['const',
                                                                                              '&']},
                                                              'types': {'key': 'MString',
                                                                        'location': 'MString'}}],
                                                'getEntry': [{'argInfo': {'index': {'doc': 'Position of the entry to retrieve information from. ',
                                                                                    'type': 'uint'},
                                                                          'key': {'doc': 'See documentation for MExternalContentLocationTable::addEntry. ',
                                                                                  'type': 'MString'},
                                                                          'location': {'doc': 'See documentation for MExternalContentLocationTable::addEntry.',
                                                                                       'type': 'MString'}},
                                                              'args': [('index',
                                                                        'uint',
                                                                        'in'),
                                                                       ('key',
                                                                        'MString',
                                                                        'out'),
                                                                       ('location',
                                                                        'MString',
                                                                        'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nNO SCRIPT SUPPORT. \n',
                                                              'inArgs': ['index'],
                                                              'outArgs': ['key',
                                                                          'location'],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'index': ['unsigned'],
                                                                                 'key': ['&'],
                                                                                 'location': ['&']},
                                                              'types': {'index': 'uint',
                                                                        'key': 'MString',
                                                                        'location': 'MString'}}],
                                                'getLocation': [{'argInfo': {'key': {'doc': 'See documentation for MExternalContentLocationTable::addEntry. ',
                                                                                     'type': 'MString'},
                                                                             'location': {'doc': 'See documentation for MExternalContentLocationTable::addEntry.',
                                                                                          'type': 'MString'}},
                                                                 'args': [('key',
                                                                           'MString',
                                                                           'in'),
                                                                          ('location',
                                                                           'MString',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nNO SCRIPT SUPPORT. \n',
                                                                 'inArgs': ['key'],
                                                                 'outArgs': ['location'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'key': ['const',
                                                                                            '&'],
                                                                                    'location': ['&']},
                                                                 'types': {'key': 'MString',
                                                                           'location': 'MString'}}],
                                                'length': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nRetrieves the number of entries in the table.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'int'},
                                                            'returnType': 'int',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}]},
                                    'pymelEnums': {}},
  'MExternalDropCallback': {'enums': {'MExternalDropStatus': {'valueDocs': {'kMayaDefault': 'Run Maya default action.',
                                                                            'kNoMayaDefaultAndAccept': 'Skip Maya default action and accept the drop.',
                                                                            'kNoMayaDefaultAndNoAccept': 'Skip Maya default action and do not accept the drop.',
                                                                            'mayaDefault': 'Run Maya default action.',
                                                                            'noMayaDefaultAndAccept': 'Skip Maya default action and accept the drop.',
                                                                            'noMayaDefaultAndNoAccept': 'Skip Maya default action and do not accept the drop.'},
                                                              'values': "Enum('MExternalDropStatus', {'kMayaDefault': 0, 'kNoMayaDefaultAndAccept': 1, 'kNoMayaDefaultAndNoAccept': 2})"}},
                            'methods': {'addCallback': [{'argInfo': {'cb': {'doc': 'The callback object to add. ',
                                                                            'type': 'MExternalDropCallback'},
                                                                     'priority': {'doc': 'The priority of the callback (zero is highest priority).',
                                                                                  'type': 'int'}},
                                                         'args': [('cb',
                                                                   'MExternalDropCallback',
                                                                   'in'),
                                                                  ('priority',
                                                                   'int',
                                                                   'in')],
                                                         'defaults': {'priority': 0},
                                                         'deprecated': False,
                                                         'doc': '\nAdd a callback to the list.',
                                                         'inArgs': ['cb',
                                                                    'priority'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': True,
                                                         'typeQualifiers': {'cb': ['*'],
                                                                            'priority': []},
                                                         'types': {'cb': 'MExternalDropCallback',
                                                                   'priority': 'int'}}],
                                        'externalDropCallback': [{'argInfo': {'controlName': {'doc': 'the full name of the UI element onto which the drop will take place ',
                                                                                              'type': 'MString'},
                                                                              'data': {'doc': 'an instance of MExternalDropData, allowing access to the data associated with the drop',
                                                                                       'type': 'MExternalDropData'},
                                                                              'doDrop': {'doc': 'true if the drop action should actually be performed (on mouse up), or false if this callback is just checking for a valid drop (on mouse drag) ',
                                                                                         'type': 'bool'}},
                                                                  'args': [('doDrop',
                                                                            'bool',
                                                                            'in'),
                                                                           ('controlName',
                                                                            'MString',
                                                                            'in'),
                                                                           ('data',
                                                                            'MExternalDropData',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nThis pure virtual method must be implemented by derived callback classes. It is called one or more times during a drag-and-drop operation, as a user drags the mouse over various UI elements.',
                                                                  'inArgs': ['doDrop',
                                                                             'controlName',
                                                                             'data'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'a status code indicating what action Maya should take following the callback ',
                                                                                 'qualifiers': [],
                                                                                 'type': ('MExternalDropCallback',
                                                                                          'MExternalDropStatus')},
                                                                  'returnType': ('MExternalDropCallback',
                                                                                 'MExternalDropStatus'),
                                                                  'static': False,
                                                                  'typeQualifiers': {'controlName': ['const',
                                                                                                     '&'],
                                                                                     'data': ['const',
                                                                                              '&'],
                                                                                     'doDrop': []},
                                                                  'types': {'controlName': 'MString',
                                                                            'data': 'MExternalDropData',
                                                                            'doDrop': 'bool'}}],
                                        'removeCallback': [{'argInfo': {'cb': {'doc': 'The callback object to remove.',
                                                                               'type': 'MExternalDropCallback'}},
                                                            'args': [('cb',
                                                                      'MExternalDropCallback',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nRemove a callback from the list.',
                                                            'inArgs': ['cb'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': True,
                                                            'typeQualifiers': {'cb': ['*']},
                                                            'types': {'cb': 'MExternalDropCallback'}}]},
                            'pymelEnums': {'MExternalDropStatus': "Enum('MExternalDropStatus', [('mayaDefault', 0), ('kMayaDefault', 0), ('noMayaDefaultAndAccept', 1), ('kNoMayaDefaultAndAccept', 1), ('noMayaDefaultAndNoAccept', 2), ('kNoMayaDefaultAndNoAccept', 2)], multiKeys=True)"}},
  'MExternalDropData': {'enums': {},
                        'methods': {'color': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nObtain the color data contained in the drop, if any.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MColor'},
                                               'returnType': 'MColor',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'dataSize': [{'argInfo': {'format': {'doc': 'The format to look for.',
                                                                         'type': 'MString'}},
                                                  'args': [('format',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturn the size (in bytes) of the data with the given format contained in the drop.',
                                                  'inArgs': ['format'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'the size of the data, in bytes (zero if the format is not present) ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'format': ['const',
                                                                                '&']},
                                                  'types': {'format': 'MString'}}],
                                    'formats': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nObtain the list of data formats contained in the drop.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MStringArray'},
                                                 'returnType': 'MStringArray',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'hasColor': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nQuery whether the drop contains color data.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'hasFormat': [{'argInfo': {'format': {'doc': 'The format to look for.',
                                                                          'type': 'MString'}},
                                                   'args': [('format',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nQuery whether the drop contains data in a given format. The result will be true iff the format is contained in the result of the  formats()  method.',
                                                   'inArgs': ['format'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true the drop contains data with the given format  false the drop does not contain data with the given format   ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'format': ['const',
                                                                                 '&']},
                                                   'types': {'format': 'MString'}}],
                                    'hasHtml': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nQuery whether the drop contains html data.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'hasImage': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nQuery whether the drop contains image data.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'hasText': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nQuery whether the drop contains text data.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'hasUrls': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nQuery whether the drop contains URL data.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'html': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nObtain the html data contained in the drop, if any.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'image': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nObtain the image data contained in the drop, if any.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MImage'},
                                               'returnType': 'MImage',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'keyboardModifiers': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturn the modifier state for this drop. Use MExternalDropData::KeyboardModifiers bitmask to distinguish the states.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                    'mouseButtons': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturn the mouse button state for this drop. Use MExternalDropData::MouseButtons bitmask to distinguish the states.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                    'text': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nObtain the text data contained in the drop, if any.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'urls': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nObtain the URL data contained in the drop, if any.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MStringArray'},
                                              'returnType': 'MStringArray',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFcurveEdit': {'enums': {},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'editType': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nVirtual method used to return the edit type of this edit, which is  MEdit::kFcurveEdit .',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'MEdit::kFcurveEdit',
                                                           'qualifiers': [],
                                                           'type': ('MEdit',
                                                                    'EditType')},
                                            'returnType': ('MEdit',
                                                           'EditType'),
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                              'fcurve': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns the fcurve node that was modified for this edit. The node can only be returned when the related reference is loaded. When the reference or assembly is unloaded, only the fcurve name string can be queried.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The fcurve that was modified for this edit',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'fcurveName': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the name of the fcurve that was modified in this edit.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of the fcurve node that was modified in this edit',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}]},
                  'pymelEnums': {}},
  'MFeedbackLine': {'enums': {},
                    'invertibles': [('setShowFeedback', 'showFeedback')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'clear': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nClear whatever is showing in the feedback line. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                'setFormat': [{'argInfo': {'format': {'doc': 'the format string for the feedback line',
                                                                      'type': 'MString'}},
                                               'args': [('format',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the format string for the feedback line. The format begins with a format specifier "^" followed by the format size, format decimal character ".", decimal size, and format type. For example: the format "^6.3f" which specifies that there is going to be one value given, it is a float, with 3 decimal places shown.',
                                               'inArgs': ['format'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'format': ['const',
                                                                             '&']},
                                               'types': {'format': 'MString'}}],
                                'setShowFeedback': [{'argInfo': {'showFeedback': {'doc': 'whether or not the feedback line should display data ',
                                                                                  'type': 'bool'}},
                                                     'args': [('showFeedback',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet whether the feedback line is supposed to be displaying data.',
                                                     'inArgs': ['showFeedback'],
                                                     'inverse': ('showFeedback',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': True,
                                                     'typeQualifiers': {'showFeedback': []},
                                                     'types': {'showFeedback': 'bool'}}],
                                'setTitle': [{'argInfo': {'title': {'doc': 'the title string',
                                                                    'type': 'MString'}},
                                              'args': [('title',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the title string.',
                                              'inArgs': ['title'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'title': ['const',
                                                                           '&']},
                                              'types': {'title': 'MString'}}],
                                'setValue': [{'argInfo': {'index': {'doc': 'the index whose value should be set ',
                                                                    'type': 'short'},
                                                          'value': {'doc': 'the value of the index',
                                                                    'type': 'double'}},
                                              'args': [('index',
                                                        'short',
                                                        'in'),
                                                       ('value',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the value of a given index in the feedback line',
                                              'inArgs': ['index',
                                                         'value'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'index': [],
                                                                 'value': []},
                                              'types': {'index': 'short',
                                                        'value': 'double'}}],
                                'showFeedback': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn whether or not the feedback line is is supposed to be displaying data.',
                                                  'inArgs': [],
                                                  'inverse': ('setShowFeedback',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'showFeedback': 'getShowFeedback'}},
  'MFileIO': {'enums': {'ExportType': {'valueDocs': {'all': 'Export all.',
                                                     'anim': 'Export anim.',
                                                     'animFromReference': 'Export anim from reference.',
                                                     'asReference': 'Export as reference.',
                                                     'edits': 'Export edits.',
                                                     'kExportTypeAll': 'Export all.',
                                                     'kExportTypeAnim': 'Export anim.',
                                                     'kExportTypeAnimFromReference': 'Export anim from reference.',
                                                     'kExportTypeAsReference': 'Export as reference.',
                                                     'kExportTypeEdits': 'Export edits.',
                                                     'kExportTypePrefObjects': 'Export pref objects.',
                                                     'kExportTypeSelected': 'Export selected.',
                                                     'prefObjects': 'Export pref objects.',
                                                     'selected': 'Export selected.'},
                                       'values': "Enum('ExportType', {'kExportTypeAll': 0, 'kExportTypeSelected': 1, 'kExportTypeAnim': 2, 'kExportTypeAnimFromReference': 3, 'kExportTypeAsReference': 4, 'kExportTypeEdits': 5, 'kExportTypePrefObjects': 6})"},
                        'NamespaceMergeMethod': {'valueDocs': {'forceDeleteNamespaceContent': 'Delete all namespace content, and delete namespace. Cannot be used if the reference resides in the root namespace.',
                                                               'kForceDeleteNamespaceContent': 'Delete all namespace content, and delete namespace. Cannot be used if the reference resides in the root namespace.',
                                                               'kMergeNamespaceWithParentNamespace': 'Move remaining objects to parent namespace, and delete namespace. Cannot be used if the reference resides in the root namespace.',
                                                               'kMergeNamespaceWithRootNamespace': 'Move remaining objects to root namespace, and delete namespace. Cannot be used if the reference resides in the root namespace.',
                                                               'kRemoveNamespaceIfEmpty': 'If the reference is alone in its namespace, remove the namespace. Else, keep the objects and the namespace.',
                                                               'mergeNamespaceWithParentNamespace': 'Move remaining objects to parent namespace, and delete namespace. Cannot be used if the reference resides in the root namespace.',
                                                               'mergeNamespaceWithRootNamespace': 'Move remaining objects to root namespace, and delete namespace. Cannot be used if the reference resides in the root namespace.',
                                                               'removeNamespaceIfEmpty': 'If the reference is alone in its namespace, remove the namespace. Else, keep the objects and the namespace.'},
                                                 'values': "Enum('NamespaceMergeMethod', {'kRemoveNamespaceIfEmpty': 0, 'kMergeNamespaceWithRootNamespace': 1, 'kMergeNamespaceWithParentNamespace': 2, 'kForceDeleteNamespaceContent': 3})"},
                        'ReferenceMode': {'valueDocs': {'allReferences': 'Load all references in the scene.',
                                                        'default': 'Load references that were loaded when scene was saved.',
                                                        'kLoadAllReferences': 'Load all references in the scene.',
                                                        'kLoadDefault': 'Load references that were loaded when scene was saved.',
                                                        'kLoadNoReferences': "Don't load any references.",
                                                        'noReferences': "Don't load any references."},
                                          'values': "Enum('ReferenceMode', {'kLoadDefault': 0, 'kLoadAllReferences': 1, 'kLoadNoReferences': 2})"}},
              'invertibles': [('setCurrentFile', 'currentFile'),
                              ('setMustRenameToSaveMsg',
                               'mustRenameToSaveMsg'),
                              ('setMustRenameToSave', 'mustRenameToSave')],
              'methods': {'beforeExportFilename': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRetrieves the name of the file requested to be exported. This name can be retrieved from within the beforeExportCheck and beforeExport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be exported). If called outside of these two callback functions the results are undefined.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The name of the file to be exported',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': True,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                          'beforeExportUserFileTranslator': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nRetrieves the plug-in-defined file translator being used for export, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeExportCheck and beforeExport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be exported). If called outside of these two callback functions the results are undefined.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'A pointer to the file translator being used to export, or NULL.',
                                                                             'qualifiers': ['*'],
                                                                             'type': 'MPxFileTranslator'},
                                                              'returnType': 'MPxFileTranslator',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                          'beforeImportFilename': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRetrieves the name of the file requested to be imported. This name can be retrieved from within the beforeImportCheck and beforeImport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be imported). If called outside of these two callback functions the results are undefined.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The name of the file to be imported',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': True,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                          'beforeImportUserFileTranslator': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nRetrieves the plug-in-defined file translator being used for import, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeImportCheck and beforeImport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be imported). If called outside of these two callback functions the results are undefined.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'A pointer to the file translator being used to import, or NULL.',
                                                                             'qualifiers': ['*'],
                                                                             'type': 'MPxFileTranslator'},
                                                              'returnType': 'MPxFileTranslator',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                          'beforeOpenFilename': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieves the name of the file requested to be opened. This name can be retrieved from within the beforeOpenCheck and beforeOpen callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be opened). If called outside of these two callback functions the results are undefined.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The name of the file to be opened',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                          'beforeOpenUserFileTranslator': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nRetrieves the plug-in-defined file translator being used for file open, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeOpenCheck and beforeOpen callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be opened). If called outside of these two callback functions the results are undefined.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'A pointer to the file translator being used for file open, or NULL.',
                                                                           'qualifiers': ['*'],
                                                                           'type': 'MPxFileTranslator'},
                                                            'returnType': 'MPxFileTranslator',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                          'beforeReferenceFilename': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nRetrieves the name of the file requested to be referenced. This name can be retrieved from within the beforeRefenceCheck and beforeRefence callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be referenced). If called outside of these two callback functions the results are undefined.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The name of the file to be referenced',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                          'beforeReferenceUserFileTranslator': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nRetrieves the plug-in-defined file translator being used for file reference, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeRefenceCheck and beforeRefence callback functions. (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be referenced). If called outside of these two callback functions the results are undefined.',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'A pointer to the file translator being used for file reference, or NULL.',
                                                                                'qualifiers': ['*'],
                                                                                'type': 'MPxFileTranslator'},
                                                                 'returnType': 'MPxFileTranslator',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                                 'types': {}}],
                          'beforeSaveFilename': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieves the name of the file requested to be saved. This name can be retrieved from within the beforeSaveCheck and beforeSave callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be saved). If called outside of these two callback functions the results are undefined.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The name of the file to be saved',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                          'beforeSaveUserFileTranslator': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nRetrieves the plug-in-defined file translator being used for file save, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeSaveCheck and beforeSave callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be saved). If called outside of these two callback functions the results are undefined.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'A pointer to the file translator being used for file save, or NULL.',
                                                                           'qualifiers': ['*'],
                                                                           'type': 'MPxFileTranslator'},
                                                            'returnType': 'MPxFileTranslator',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'cleanReference': [{'argInfo': {'editCommand': {'doc': 'Name of the edit command to be cleaned. ',
                                                                          'type': 'char'},
                                                          'referenceNodeName': {'doc': 'Name of the reference node. ',
                                                                                'type': 'MString'}},
                                              'args': [('referenceNodeName',
                                                        'MString',
                                                        'in'),
                                                       ('editCommand',
                                                        'char',
                                                        'in')],
                                              'defaults': {'editCommand': None},
                                              'deprecated': False,
                                              'doc': '\r\nThis function removes the edits from the passed in reference node. The reference must be in an unloaded state.',
                                              'inArgs': ['referenceNodeName',
                                                         'editCommand'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'editCommand': ['const',
                                                                                 '*'],
                                                                 'referenceNodeName': ['const',
                                                                                       '&'],
                                                                 'returnStatus': ['*']},
                                              'types': {'editCommand': 'char',
                                                        'referenceNodeName': 'MString'}}],
                          'currentFile': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the name of the currently active scene.',
                                           'inArgs': [],
                                           'inverse': ('setCurrentFile',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'An MString containing the file name ',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                          'currentlyReadingFileVersion': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nEach Maya file format version has a unique integer identifier. Identifiers go up sequentially with each new file format.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                          'exportAll': [{'argInfo': {'fileName': {'doc': 'name of the file to which to export the objects ',
                                                                  'type': 'MString'},
                                                     'preserveReferences': {'doc': 'Boolean to indicate whether the references need to be preserved.',
                                                                            'type': 'bool'},
                                                     'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file. ',
                                                              'type': 'char'}},
                                         'args': [('fileName',
                                                   'MString',
                                                   'in'),
                                                  ('type', 'char', 'in'),
                                                  ('preserveReferences',
                                                   'bool',
                                                   'in')],
                                         'defaults': {'preserveReferences': False,
                                                      'type': None},
                                         'deprecated': False,
                                         'doc': '\r\nExport the current scene to the given file.',
                                         'inArgs': ['fileName',
                                                    'type',
                                                    'preserveReferences'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': True,
                                         'typeQualifiers': {'fileName': ['const',
                                                                         '&'],
                                                            'preserveReferences': [],
                                                            'type': ['const',
                                                                     '*']},
                                         'types': {'fileName': 'MString',
                                                   'preserveReferences': 'bool',
                                                   'type': 'char'}}],
                          'exportAnim': [{'argInfo': {'fileName': {'doc': 'name of the file to which the animation will be exported. ',
                                                                   'type': 'MString'},
                                                      'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file.',
                                                               'type': 'char'}},
                                          'args': [('fileName',
                                                    'MString',
                                                    'in'),
                                                   ('type',
                                                    'char',
                                                    'in')],
                                          'defaults': {'type': None},
                                          'deprecated': False,
                                          'doc': '\r\nExport animation to the specified file.',
                                          'inArgs': ['fileName', 'type'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'fileName': ['const',
                                                                          '&'],
                                                             'type': ['const',
                                                                      '*']},
                                          'types': {'fileName': 'MString',
                                                    'type': 'char'}}],
                          'exportAnimFromReference': [{'argInfo': {'fileName': {'doc': 'name of the file to which the animation will be exported. ',
                                                                                'type': 'MString'},
                                                                   'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file.',
                                                                            'type': 'char'}},
                                                       'args': [('fileName',
                                                                 'MString',
                                                                 'in'),
                                                                ('type',
                                                                 'char',
                                                                 'in')],
                                                       'defaults': {'type': None},
                                                       'deprecated': False,
                                                       'doc': '\r\nExport the animation from reference, to the specified file.',
                                                       'inArgs': ['fileName',
                                                                  'type'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': True,
                                                       'typeQualifiers': {'fileName': ['const',
                                                                                       '&'],
                                                                          'type': ['const',
                                                                                   '*']},
                                                       'types': {'fileName': 'MString',
                                                                 'type': 'char'}},
                                                      {'argInfo': {'fileName': {'doc': 'name of the file to which the animation will be exported. ',
                                                                                'type': 'MString'},
                                                                   'refNodeName': {'doc': 'name of the reference whose animation will be exported. ',
                                                                                   'type': 'MString'},
                                                                   'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file.',
                                                                            'type': 'char'}},
                                                       'args': [('fileName',
                                                                 'MString',
                                                                 'in'),
                                                                ('refNodeName',
                                                                 'MString',
                                                                 'in'),
                                                                ('type',
                                                                 'char',
                                                                 'in')],
                                                       'defaults': {'type': None},
                                                       'deprecated': False,
                                                       'doc': '\r\nExport the animation from the specified reference node, to the specified file.',
                                                       'inArgs': ['fileName',
                                                                  'refNodeName',
                                                                  'type'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': True,
                                                       'typeQualifiers': {'fileName': ['const',
                                                                                       '&'],
                                                                          'refNodeName': ['const',
                                                                                          '&'],
                                                                          'type': ['const',
                                                                                   '*']},
                                                       'types': {'fileName': 'MString',
                                                                 'refNodeName': 'MString',
                                                                 'type': 'char'}}],
                          'exportAsReference': [{'argInfo': {'fileName': {'doc': 'name of the file to which the selected objects will be exported as reference. ',
                                                                          'type': 'MString'},
                                                             'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file.',
                                                                      'type': 'char'}},
                                                 'args': [('fileName',
                                                           'MString',
                                                           'in'),
                                                          ('type',
                                                           'char',
                                                           'in')],
                                                 'defaults': {'type': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nExport the selected objects into a reference file.',
                                                 'inArgs': ['fileName',
                                                            'type'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {'fileName': ['const',
                                                                                 '&'],
                                                                    'type': ['const',
                                                                             '*']},
                                                 'types': {'fileName': 'MString',
                                                           'type': 'char'}}],
                          'exportSelected': [{'argInfo': {'fileName': {'doc': 'name of the file to which to export the objects ',
                                                                       'type': 'MString'},
                                                          'preserveReferences': {'doc': 'Boolean to indicate whether the references need to be preserved.',
                                                                                 'type': 'bool'},
                                                          'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file. ',
                                                                   'type': 'char'}},
                                              'args': [('fileName',
                                                        'MString',
                                                        'in'),
                                                       ('type',
                                                        'char',
                                                        'in'),
                                                       ('preserveReferences',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'preserveReferences': False,
                                                           'type': None},
                                              'deprecated': False,
                                              'doc': '\r\nExport all currently selected scene elements to the given file.',
                                              'inArgs': ['fileName',
                                                         'type',
                                                         'preserveReferences'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'fileName': ['const',
                                                                              '&'],
                                                                 'preserveReferences': [],
                                                                 'type': ['const',
                                                                          '*']},
                                              'types': {'fileName': 'MString',
                                                        'preserveReferences': 'bool',
                                                        'type': 'char'}}],
                          'exportSelectedAnim': [{'argInfo': {'fileName': {'doc': 'name of the file to which the animation will be exported. ',
                                                                           'type': 'MString'},
                                                              'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file.',
                                                                       'type': 'char'}},
                                                  'args': [('fileName',
                                                            'MString',
                                                            'in'),
                                                           ('type',
                                                            'char',
                                                            'in')],
                                                  'defaults': {'type': None},
                                                  'deprecated': False,
                                                  'doc': '\r\nExport selected animation to the specified file.',
                                                  'inArgs': ['fileName',
                                                             'type'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {'fileName': ['const',
                                                                                  '&'],
                                                                     'type': ['const',
                                                                              '*']},
                                                  'types': {'fileName': 'MString',
                                                            'type': 'char'}}],
                          'exportSelectedAnimFromReference': [{'argInfo': {'fileName': {'doc': 'name of the file to which the animation will be exported. ',
                                                                                        'type': 'MString'},
                                                                           'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file.',
                                                                                    'type': 'char'}},
                                                               'args': [('fileName',
                                                                         'MString',
                                                                         'in'),
                                                                        ('type',
                                                                         'char',
                                                                         'in')],
                                                               'defaults': {'type': None},
                                                               'deprecated': False,
                                                               'doc': '\r\nExport the selected animation from reference, to the specified file.',
                                                               'inArgs': ['fileName',
                                                                          'type'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': True,
                                                               'typeQualifiers': {'fileName': ['const',
                                                                                               '&'],
                                                                                  'type': ['const',
                                                                                           '*']},
                                                               'types': {'fileName': 'MString',
                                                                         'type': 'char'}},
                                                              {'argInfo': {'fileName': {'doc': 'name of the file to which the animation will be exported. ',
                                                                                        'type': 'MString'},
                                                                           'refNodeName': {'doc': 'name of the reference whose animation will be exported. ',
                                                                                           'type': 'MString'},
                                                                           'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file.',
                                                                                    'type': 'char'}},
                                                               'args': [('fileName',
                                                                         'MString',
                                                                         'in'),
                                                                        ('refNodeName',
                                                                         'MString',
                                                                         'in'),
                                                                        ('type',
                                                                         'char',
                                                                         'in')],
                                                               'defaults': {'type': None},
                                                               'deprecated': False,
                                                               'doc': '\r\nExport the selected animation from reference, to the specified file.',
                                                               'inArgs': ['fileName',
                                                                          'refNodeName',
                                                                          'type'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': True,
                                                               'typeQualifiers': {'fileName': ['const',
                                                                                               '&'],
                                                                                  'refNodeName': ['const',
                                                                                                  '&'],
                                                                                  'type': ['const',
                                                                                           '*']},
                                                               'types': {'fileName': 'MString',
                                                                         'refNodeName': 'MString',
                                                                         'type': 'char'}}],
                          'exportType': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the type of export currently in progress. The result is valid from the start of the kBeforeExportCheck callback through to the end of the kAfterExport callback, and for any callbacks which occur between them. See  MSceneMessage  for more information on these callbacks.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The type of export currently in progress.',
                                                         'qualifiers': [],
                                                         'type': ('MFileIO',
                                                                  'ExportType')},
                                          'returnType': ('MFileIO',
                                                         'ExportType'),
                                          'static': True,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                          'fileCurrentlyLoading': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the name of the file currently being loaded.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'An MString containing the name of the file being loaded. An empty string if no load is taking place. ',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                          'fileType': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturn the type of the current active scene.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': ' MS::kSuccess operation successful  MS::kFailure operation failed   ',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                          'getErrorStatus': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the error status of the last file read. Returns true if any error occurred during the last file read, else false is returned.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean value indicating the error status.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': True,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                          'getFileTypes': [{'argInfo': {'types': {'doc': 'a reference to an MStringArray which on return contains the list of supported file types.',
                                                                  'type': 'MStringArray'}},
                                            'args': [('types',
                                                      'MStringArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns an array of all the valid type names that Maya currently supports. Only elements from this list are valid arguments for the  type  arguments to  open ,  saveAs ,  import ,  exportSelected , and  exportAll .',
                                            'inArgs': [],
                                            'outArgs': ['types'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'types': ['&']},
                                            'types': {'types': 'MStringArray'}}],
                          'getFiles': [{'argInfo': {'files': {'doc': 'a reference to an MStringArray which on return contains the list of referenced files. ',
                                                              'type': 'MStringArray'},
                                                    'wantReferencesOnly': {'doc': 'specify if only file references should be returned. Setting this to true makes this function equivalent to MFileIO::getReferences(). Default is false.',
                                                                           'type': 'bool'},
                                                    'wantUnresolvedNames': {'doc': 'specify if unresolved file names should be returned. Default is false. ',
                                                                            'type': 'bool'}},
                                        'args': [('files',
                                                  'MStringArray',
                                                  'out'),
                                                 ('wantUnresolvedNames',
                                                  'bool',
                                                  'in'),
                                                 ('wantReferencesOnly',
                                                  'bool',
                                                  'in')],
                                        'defaults': {'wantReferencesOnly': False,
                                                     'wantUnresolvedNames': False},
                                        'deprecated': False,
                                        'doc': '\r\nReturn an array of all the files used by the currently active scene. Includes file references, file textures, cache files, image planes etc.',
                                        'inArgs': ['wantUnresolvedNames',
                                                   'wantReferencesOnly'],
                                        'outArgs': ['files'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': True,
                                        'typeQualifiers': {'files': ['&'],
                                                           'wantReferencesOnly': [],
                                                           'wantUnresolvedNames': []},
                                        'types': {'files': 'MStringArray',
                                                  'wantReferencesOnly': 'bool',
                                                  'wantUnresolvedNames': 'bool'}}],
                          'getLastTempFile': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the temp file used during file save.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The name of the temp file',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': True,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'getReferenceConnectionsBroken': [{'argInfo': {'connections': {'doc': 'a reference to an MStringArray which on return contains the source/destination connection pairs.',
                                                                                         'type': 'MStringArray'},
                                                                         'fileName': {'doc': 'an MString which contains the name of the referenced file. ',
                                                                                      'type': 'MString'}},
                                                             'args': [('fileName',
                                                                       'MString',
                                                                       'in'),
                                                                      ('connections',
                                                                       'MStringArray',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturn an array of attribute pairs representing connections broken to nodes in the given referenced file. The first element of the pair is the source attribute in the connection, and the second is the destination. These pairs correspond to the "disconnectAttr" statements in a scene file where changes to the referenced file occur after the referenced file has been opened.',
                                                             'inArgs': ['fileName'],
                                                             'outArgs': ['connections'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'connections': ['&'],
                                                                                'fileName': ['const',
                                                                                             '&']},
                                                             'types': {'connections': 'MStringArray',
                                                                       'fileName': 'MString'}},
                                                            {'argInfo': {'destPlugs': {'doc': 'an MPlugArray which contains the destination plugs of each broken connection.',
                                                                                       'type': 'MPlugArray'},
                                                                         'fileName': {'doc': 'an MString which contains the name of the referenced file.',
                                                                                      'type': 'MString'},
                                                                         'srcPlugs': {'doc': 'an MPlugArray which will receive the source plugs of each broken connection.',
                                                                                      'type': 'MPlugArray'}},
                                                             'args': [('fileName',
                                                                       'MString',
                                                                       'in'),
                                                                      ('srcPlugs',
                                                                       'MPlugArray',
                                                                       'out'),
                                                                      ('destPlugs',
                                                                       'MPlugArray',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturns the source and destination plugs corresponding to all the connections broken between nodes in the given referenced file. These pairs correspond to the "disconnectAttr" statements in a scene file where changes to the referenced file occur after the referenced file has been opened.',
                                                             'inArgs': ['fileName'],
                                                             'outArgs': ['srcPlugs',
                                                                         'destPlugs'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'destPlugs': ['&'],
                                                                                'fileName': ['const',
                                                                                             '&'],
                                                                                'srcPlugs': ['&']},
                                                             'types': {'destPlugs': 'MPlugArray',
                                                                       'fileName': 'MString',
                                                                       'srcPlugs': 'MPlugArray'}},
                                                            {'argInfo': {'append': {'doc': 'If true, the connection strings will be appended to the existing contents of the connections array. Otherwise the array will be cleared before the strings are added. ',
                                                                                    'type': 'bool'},
                                                                         'connections': {'doc': 'a reference to an MStringArray which on return contains the source/destination connection pairs. ',
                                                                                         'type': 'MStringArray'},
                                                                         'node': {'doc': 'the node whose broken reference connections will be returned. ',
                                                                                  'type': 'MObject'},
                                                                         'removeDuplicates': {'doc': 'If true then any connections which are already in the connections array will be ignored. Otherwise they will be added to the array again.',
                                                                                              'type': 'bool'}},
                                                             'args': [('node',
                                                                       'MObject',
                                                                       'in'),
                                                                      ('connections',
                                                                       'MStringArray',
                                                                       'out'),
                                                                      ('append',
                                                                       'bool',
                                                                       'in'),
                                                                      ('removeDuplicates',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {'append': False,
                                                                          'removeDuplicates': True},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturns an array of plug name pairs corresponding to the broken connections from referenced files, where those connections involved the specified node.',
                                                             'inArgs': ['node',
                                                                        'append',
                                                                        'removeDuplicates'],
                                                             'outArgs': ['connections'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'append': [],
                                                                                'connections': ['&'],
                                                                                'node': ['const',
                                                                                         '&'],
                                                                                'removeDuplicates': []},
                                                             'types': {'append': 'bool',
                                                                       'connections': 'MStringArray',
                                                                       'node': 'MObject',
                                                                       'removeDuplicates': 'bool'}},
                                                            {'argInfo': {'append': {'doc': 'if true, then srcPlugs and destPlugs will not be initially cleared, meaning that the plugs from any broken connections found will be appended after whatever is already in those arrays. This can be useful for building up an array of connections for several nodes.',
                                                                                    'type': 'bool'},
                                                                         'destPlugs': {'doc': 'an MPlugArray which will receive the destination plugs of each broken connection.',
                                                                                       'type': 'MPlugArray'},
                                                                         'node': {'doc': 'the node whose broken connections should be returned.',
                                                                                  'type': 'MObject'},
                                                                         'removeDuplicates': {'doc': 'if the append parameter is true, then it is possible that some of the broken connections found for node will already exist in plug arrays. For example, if node A and node B have a broken reference connection between them, then they will both return that connection when passed to this method. Setting removeDuplicates true will cause these duplicate connections to only appear in the plug arrays once.',
                                                                                              'type': 'bool'},
                                                                         'srcPlugs': {'doc': 'an MPlugArray which will receive the source plugs of each broken connection.',
                                                                                      'type': 'MPlugArray'}},
                                                             'args': [('node',
                                                                       'MObject',
                                                                       'in'),
                                                                      ('srcPlugs',
                                                                       'MPlugArray',
                                                                       'out'),
                                                                      ('destPlugs',
                                                                       'MPlugArray',
                                                                       'out'),
                                                                      ('append',
                                                                       'bool',
                                                                       'in'),
                                                                      ('removeDuplicates',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {'append': False,
                                                                          'removeDuplicates': True},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturns arrays of source and destination plugs corresponding to the broken connections from referenced files, where those connections involved the specified node.',
                                                             'inArgs': ['node',
                                                                        'append',
                                                                        'removeDuplicates'],
                                                             'outArgs': ['srcPlugs',
                                                                         'destPlugs'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'append': [],
                                                                                'destPlugs': ['&'],
                                                                                'node': ['const',
                                                                                         '&'],
                                                                                'removeDuplicates': [],
                                                                                'srcPlugs': ['&']},
                                                             'types': {'append': 'bool',
                                                                       'destPlugs': 'MPlugArray',
                                                                       'node': 'MObject',
                                                                       'removeDuplicates': 'bool',
                                                                       'srcPlugs': 'MPlugArray'}}],
                          'getReferenceConnectionsMade': [{'argInfo': {'connections': {'doc': 'a reference to an MStringArray which on return contains the source/destination connection pairs.',
                                                                                       'type': 'MStringArray'},
                                                                       'fileName': {'doc': 'an MString which contains the name of the referenced file. ',
                                                                                    'type': 'MString'}},
                                                           'args': [('fileName',
                                                                     'MString',
                                                                     'in'),
                                                                    ('connections',
                                                                     'MStringArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturn an array of attribute pairs representing connections made to nodes in the given referenced file. The first element of the pair is the source attribute in the connection, and the second is the destination. These pairs correspond to the "connectAttr" statements in a scene file where changes to the referenced file occur after the referenced file has been opened.',
                                                           'inArgs': ['fileName'],
                                                           'outArgs': ['connections'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': True,
                                                           'typeQualifiers': {'connections': ['&'],
                                                                              'fileName': ['const',
                                                                                           '&']},
                                                           'types': {'connections': 'MStringArray',
                                                                     'fileName': 'MString'}}],
                          'getReferenceFileByNode': [{'argInfo': {'referenceNode': {'doc': 'MObject containing the reference node. ',
                                                                                    'type': 'MObject'}},
                                                      'args': [('referenceNode',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the name of the reference file, which contains the given reference node.',
                                                      'inArgs': ['referenceNode'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The name of the reference file, containing the given node.',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': True,
                                                      'typeQualifiers': {'referenceNode': ['&'],
                                                                         'returnStatus': ['*']},
                                                      'types': {'referenceNode': 'MObject'}}],
                          'getReferenceNodes': [{'argInfo': {'fileName': {'doc': 'an MString which contains the name of the referenced file. ',
                                                                          'type': 'MString'},
                                                             'nodes': {'doc': 'a reference to an MStringArray which on return contains the list of nodes in the referenced file.',
                                                                       'type': 'MStringArray'}},
                                                 'args': [('fileName',
                                                           'MString',
                                                           'in'),
                                                          ('nodes',
                                                           'MStringArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn an array of all the nodes referenced by the given filename.',
                                                 'inArgs': ['fileName'],
                                                 'outArgs': ['nodes'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {'fileName': ['const',
                                                                                 '&'],
                                                                    'nodes': ['&']},
                                                 'types': {'fileName': 'MString',
                                                           'nodes': 'MStringArray'}},
                                                {'argInfo': {'fileName': {'doc': 'an MString which contains the name of the referenced file. ',
                                                                          'type': 'MString'},
                                                             'list': {'doc': 'a reference to an MSelectionList which on return contains the list of nodes in the referenced file.',
                                                                      'type': 'MSelectionList'}},
                                                 'args': [('fileName',
                                                           'MString',
                                                           'in'),
                                                          ('list',
                                                           'MSelectionList',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn an array of all the nodes referenced by the given filename.',
                                                 'inArgs': ['fileName'],
                                                 'outArgs': ['list'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {'fileName': ['const',
                                                                                 '&'],
                                                                    'list': ['&']},
                                                 'types': {'fileName': 'MString',
                                                           'list': 'MSelectionList'}}],
                          'getReferences': [{'argInfo': {'references': {'doc': 'a reference to an MStringArray which on return contains the list of referenced files. ',
                                                                        'type': 'MStringArray'},
                                                         'wantUnresolvedNames': {'doc': 'specify if unresolved file names should be returned. Default is false.',
                                                                                 'type': 'bool'}},
                                             'args': [('references',
                                                       'MStringArray',
                                                       'out'),
                                                      ('wantUnresolvedNames',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'wantUnresolvedNames': False},
                                             'deprecated': False,
                                             'doc': '\r\nReturn an array of all the files referenced from the currently active scene.',
                                             'inArgs': ['wantUnresolvedNames'],
                                             'outArgs': ['references'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'references': ['&'],
                                                                'wantUnresolvedNames': []},
                                             'types': {'references': 'MStringArray',
                                                       'wantUnresolvedNames': 'bool'}}],
                          'importFile': [{'argInfo': {'fileName': {'doc': 'name of the file from which to import objects ',
                                                                   'type': 'MString'},
                                                      'ignoreVersion': {'doc': 'Boolean to control whether to ignore version when importing a file. ',
                                                                        'type': 'bool'},
                                                      'nameSpace': {'doc': 'optional name of the namespace to use when importing objects. Use NULL for default of no namespace. ',
                                                                    'type': 'char'},
                                                      'preserveReferences': {'doc': 'Boolean to indicate whether the references need to be preserved. ',
                                                                             'type': 'bool'},
                                                      'type': {'doc': 'if NULL, Maya will try to deduce the type of the file. If not NULL, it must contain a file type to use when importing the file. ',
                                                               'type': 'char'}},
                                          'args': [('fileName',
                                                    'MString',
                                                    'in'),
                                                   ('type',
                                                    'char',
                                                    'in'),
                                                   ('preserveReferences',
                                                    'bool',
                                                    'in'),
                                                   ('nameSpace',
                                                    'char',
                                                    'in'),
                                                   ('ignoreVersion',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'ignoreVersion': False,
                                                       'nameSpace': None,
                                                       'preserveReferences': False,
                                                       'type': None},
                                          'deprecated': False,
                                          'doc': '\r\nImport the scene elements from the given file into the current scene. This operation is similar to open, but instead of replacing the current scene with the one from the new file, it adds the elements from that file to the existing ones in the current scene.',
                                          'inArgs': ['fileName',
                                                     'type',
                                                     'preserveReferences',
                                                     'nameSpace',
                                                     'ignoreVersion'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'fileName': ['const',
                                                                          '&'],
                                                             'ignoreVersion': [],
                                                             'nameSpace': ['const',
                                                                           '*'],
                                                             'preserveReferences': [],
                                                             'type': ['const',
                                                                      '*']},
                                          'types': {'fileName': 'MString',
                                                    'ignoreVersion': 'bool',
                                                    'nameSpace': 'char',
                                                    'preserveReferences': 'bool',
                                                    'type': 'char'}}],
                          'isImportingFile': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermine if Maya is currently in the middle of a file import operation. File import operations are a subset of file reading operations.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                          'isNewingFile': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermine if Maya is currently performing a "new" operation.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                          'isOpeningFile': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermine if Maya is currently performing a file open operation.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': ' true if maya is currently in the process of opening a file  false if maya is not currently opening a file   ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                          'isReadingFile': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermine if Maya is currently in the middle of a file read operation. File import operations and file reference operations are both also file read operations.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': ' true if maya is currently in the process of reading a file  false if maya is not currently reading a file   ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                          'isReferencingFile': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nDetermine if Maya is currently in the middle of a file reference operation. File reference operations are a subset of file reading operations.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                          'isSavingReference': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nDetermine if Maya is currently in the middle of a save reference operation. i.e. When you do File > Save Reference Edits from the Reference Editor or `file -saveReference`.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                          'isWritingFile': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermine if Maya is currently in the middle of a file write operation.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                          'latestMayaFileVersion': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nEach Maya file format version has a unique integer identifier. This method returns the identifier for the file format version that will be saved by this version of Maya.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                          'loadReference': [{'argInfo': {'referenceFileName': {'doc': 'MString containing the name of the reference file. ',
                                                                               'type': 'MString'}},
                                             'args': [('referenceFileName',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nLoads the reference, referenced by the given reference node name and file name.',
                                             'inArgs': ['referenceFileName'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The name of the loaded reference file',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': True,
                                             'typeQualifiers': {'referenceFileName': ['const',
                                                                                      '&'],
                                                                'returnStatus': ['*']},
                                             'types': {'referenceFileName': 'MString'}}],
                          'loadReferenceByNode': [{'argInfo': {'referenceNodeName': {'doc': 'MString, name of the reference node. ',
                                                                                     'type': 'MString'}},
                                                   'args': [('referenceNodeName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nLoads the reference, referenced by the given reference node name.',
                                                   'inArgs': ['referenceNodeName'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The name of the loaded reference file',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': True,
                                                   'typeQualifiers': {'referenceNodeName': ['const',
                                                                                            '&'],
                                                                      'returnStatus': ['*']},
                                                   'types': {'referenceNodeName': 'MString'}},
                                                  {'argInfo': {'referenceNode': {'doc': 'MObject of the reference node. ',
                                                                                 'type': 'MObject'}},
                                                   'args': [('referenceNode',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nLoads the reference, referenced by the given reference node object.',
                                                   'inArgs': ['referenceNode'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The name of the loaded reference file',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': True,
                                                   'typeQualifiers': {'referenceNode': ['&'],
                                                                      'returnStatus': ['*']},
                                                   'types': {'referenceNode': 'MObject'}}],
                          'mustRenameToSave': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nScenes may be flagged as needing to be renamed before saving. The purpose is to prevent overwriting the original file, which may have had a significant change. Users will need to use save as to save the scene with a different file name.',
                                                'inArgs': [],
                                                'inverse': ('setMustRenameToSave',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true if this file must be renamed before saving.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                          'mustRenameToSaveMsg': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method returns a string that is displayed when a user attempts to save a scene that was set to not overwrite itself. See the  MFileIO::setMustRenameToSave()  documentation.',
                                                   'inArgs': [],
                                                   'inverse': ('setMustRenameToSaveMsg',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The error message to display.',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                          'newFile': [{'argInfo': {'force': {'doc': 'succeed even if there are unsaved changes',
                                                             'type': 'bool'}},
                                       'args': [('force', 'bool', 'in')],
                                       'defaults': {'force': False},
                                       'deprecated': False,
                                       'doc': '\r\nSet everything back to a new file state.',
                                       'inArgs': ['force'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': True,
                                       'typeQualifiers': {'force': []},
                                       'types': {'force': 'bool'}}],
                          'open': [{'argInfo': {'fileName': {'doc': 'name of the file to open ',
                                                             'type': 'MString'},
                                                'force': {'doc': 'succeed even if there are unsaved changes ',
                                                          'type': 'bool'},
                                                'ignoreVersion': {'doc': 'if true, then Maya will ignore the version number when opening the file',
                                                                  'type': 'bool'},
                                                'refMode': {'doc': 'specify whether to load all references, no references, or the references that were loaded when the scene was saved. ',
                                                            'type': ('MFileIO',
                                                                     'ReferenceMode')},
                                                'type': {'doc': 'if NULL, Maya will try to deduce the type of the file. if not NULL, it contains a file type to use when opening the file. ',
                                                         'type': 'char'}},
                                    'args': [('fileName',
                                              'MString',
                                              'in'),
                                             ('type', 'char', 'in'),
                                             ('force', 'bool', 'in'),
                                             ('refMode',
                                              ('MFileIO',
                                               'ReferenceMode'),
                                              'in'),
                                             ('ignoreVersion',
                                              'bool',
                                              'in')],
                                    'defaults': {'force': False,
                                                 'ignoreVersion': False,
                                                 'refMode': ('MFileIO',
                                                             'ReferenceMode',
                                                             'kLoadDefault'),
                                                 'type': None},
                                    'deprecated': False,
                                    'doc': '\r\nOpen the given file, and set the current active scene to this file. If there are unsaved changes in the current scene, this operation will fail unless the force flag is set to true.',
                                    'inArgs': ['fileName',
                                               'type',
                                               'force',
                                               'refMode',
                                               'ignoreVersion'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': True,
                                    'typeQualifiers': {'fileName': ['const',
                                                                    '&'],
                                                       'force': [],
                                                       'ignoreVersion': [],
                                                       'refMode': [],
                                                       'type': ['const',
                                                                '*']},
                                    'types': {'fileName': 'MString',
                                              'force': 'bool',
                                              'ignoreVersion': 'bool',
                                              'refMode': ('MFileIO',
                                                          'ReferenceMode'),
                                              'type': 'char'}}],
                          'reference': [{'argInfo': {'deferReference': {'doc': 'boolean to indicate whether loading has to be deferred. ',
                                                                        'type': 'bool'},
                                                     'fileName': {'doc': 'name of the file to add as a reference. ',
                                                                  'type': 'MString'},
                                                     'lockReference': {'doc': 'If true, all nodes and attributes from the referenced file will be locked. ',
                                                                       'type': 'bool'},
                                                     'nameSpace': {'doc': 'name space to add the contents of the referenced file to. If no namespace is provided, name-clashes will be resolved by prefixing with the filename.',
                                                                   'type': 'MString'}},
                                         'args': [('fileName',
                                                   'MString',
                                                   'in'),
                                                  ('deferReference',
                                                   'bool',
                                                   'in'),
                                                  ('lockReference',
                                                   'bool',
                                                   'in'),
                                                  ('nameSpace',
                                                   'MString',
                                                   'in')],
                                         'defaults': {'deferReference': False,
                                                      'lockReference': False,
                                                      'nameSpace': '""'},
                                         'deprecated': False,
                                         'doc': '\r\nAdd the given filename as a reference from the current file. When a new file is opened, the contents of any files it references are read into the scene, however maya remembers that the elements came from the referenced file, and does not write them during a save operation. Instead the reference is written so the contents of the referenced file (which might have changed) will be read again when the scene is reloaded.',
                                         'inArgs': ['fileName',
                                                    'deferReference',
                                                    'lockReference',
                                                    'nameSpace'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': True,
                                         'typeQualifiers': {'deferReference': [],
                                                            'fileName': ['const',
                                                                         '&'],
                                                            'lockReference': [],
                                                            'nameSpace': ['const',
                                                                          '&']},
                                         'types': {'deferReference': 'bool',
                                                   'fileName': 'MString',
                                                   'lockReference': 'bool',
                                                   'nameSpace': 'MString'}}],
                          'removeReference': [{'argInfo': {'fileName': {'doc': 'name of the file to remove as a reference ',
                                                                        'type': 'MString'},
                                                           'namespaceMergeMethod': {'doc': 'what to do with objects remaining in the namespace after the file is removed: merge with parent namespace, merge with root namespace, delete all objects, or keep objects in the namespace (default). Merge with parent/root and delete all objects cannot be used if the reference resides in the root namespace.',
                                                                                    'type': ('MFileIO',
                                                                                             'NamespaceMergeMethod')}},
                                               'args': [('fileName',
                                                         'MString',
                                                         'in'),
                                                        ('namespaceMergeMethod',
                                                         ('MFileIO',
                                                          'NamespaceMergeMethod'),
                                                         'in')],
                                               'defaults': {'namespaceMergeMethod': ('MFileIO',
                                                                                     'NamespaceMergeMethod',
                                                                                     'kRemoveNamespaceIfEmpty')},
                                               'deprecated': False,
                                               'doc': '\r\nRemove the named file as a reference from the current file.',
                                               'inArgs': ['fileName',
                                                          'namespaceMergeMethod'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'fileName': ['const',
                                                                               '&'],
                                                                  'namespaceMergeMethod': []},
                                               'types': {'fileName': 'MString',
                                                         'namespaceMergeMethod': ('MFileIO',
                                                                                  'NamespaceMergeMethod')}}],
                          'resetError': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nResets the error.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'save': [{'argInfo': {'force': {'doc': 'succeed even if there have been no changes',
                                                          'type': 'bool'}},
                                    'args': [('force', 'bool', 'in')],
                                    'defaults': {'force': False},
                                    'deprecated': False,
                                    'doc': '\r\nSave the contents of the current scene. If there have been no changes to the scene since the last save, then this operation will succeed, but not actually rewrite the save file unless the force flag is set to true.',
                                    'inArgs': ['force'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': True,
                                    'typeQualifiers': {'force': []},
                                    'types': {'force': 'bool'}}],
                          'saveAs': [{'argInfo': {'fileName': {'doc': 'name of the file to write to ',
                                                               'type': 'MString'},
                                                  'force': {'doc': 'succeed even if there have been no changes since the last save operation',
                                                            'type': 'bool'},
                                                  'type': {'doc': 'if NULL, Maya will write the file in mayaAscii format. if not NULL, it contains a file type to use when writing the file. ',
                                                           'type': 'char'}},
                                      'args': [('fileName',
                                                'MString',
                                                'in'),
                                               ('type', 'char', 'in'),
                                               ('force', 'bool', 'in')],
                                      'defaults': {'force': False,
                                                   'type': None},
                                      'deprecated': False,
                                      'doc': '\r\nSave the contents of the current scene to the given file. If there have been no changes to the scene since the last save, then this operation will succeed, but not actually rewrite the save file unless the force flag is set to true.',
                                      'inArgs': ['fileName',
                                                 'type',
                                                 'force'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': True,
                                      'typeQualifiers': {'fileName': ['const',
                                                                      '&'],
                                                         'force': [],
                                                         'type': ['const',
                                                                  '*']},
                                      'types': {'fileName': 'MString',
                                                'force': 'bool',
                                                'type': 'char'}}],
                          'saveReference': [{'argInfo': {'referenceFileName': {'doc': 'Name of the reference file. ',
                                                                               'type': 'MString'}},
                                             'args': [('referenceFileName',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis function saves reference node edits and connections to reference file',
                                             'inArgs': ['referenceFileName'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'referenceFileName': ['const',
                                                                                      '&'],
                                                                'returnStatus': ['*']},
                                             'types': {'referenceFileName': 'MString'}}],
                          'setCurrentFile': [{'argInfo': {'fileName': {'doc': 'the name of the new active scene.',
                                                                       'type': 'MString'}},
                                              'args': [('fileName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the name of the current active scene.',
                                              'inArgs': ['fileName'],
                                              'inverse': ('currentFile',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'fileName': ['const',
                                                                              '&']},
                                              'types': {'fileName': 'MString'}}],
                          'setError': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the internal errorIO flag. Setting this flag will trigger the display of the standard Maya file IO pop-up after a read or write operation. This method can be called during the  MSceneMessage::kAfterFileRead  callback.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                          'setMustRenameToSave': [{'argInfo': {'rename': {'doc': 'true, if the scene should be saved to a different name.',
                                                                          'type': 'bool'}},
                                                   'args': [('rename',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method enabled or disables a state where the current Maya scene must save to a different file name. This can be used to prevent a user from overwriting the original scene if a particularly dangerous or experimental change was made.',
                                                   'inArgs': ['rename'],
                                                   'inverse': ('mustRenameToSave',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'rename': []},
                                                   'types': {'rename': 'bool'}}],
                          'setMustRenameToSaveMsg': [{'argInfo': {'errorMsg': {'doc': 'The message to display when attempting a file save.',
                                                                               'type': 'MString'}},
                                                      'args': [('errorMsg',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method sets a string that is displayed when a user attempts to save a scene that was set to not overwrite itself. See the  MFileIO::setMustRenameToSave()  documentation.',
                                                      'inArgs': ['errorMsg'],
                                                      'inverse': ('mustRenameToSaveMsg',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'errorMsg': ['const',
                                                                                      '&']},
                                                      'types': {'errorMsg': 'MString'}}],
                          'unloadReference': [{'argInfo': {'referenceFileName': {'doc': 'MString containing the name of the reference file. ',
                                                                                 'type': 'MString'}},
                                               'args': [('referenceFileName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nUnloads the reference, referenced by the given reference node and file.',
                                               'inArgs': ['referenceFileName'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The name of the unloaded reference file',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': True,
                                               'typeQualifiers': {'referenceFileName': ['const',
                                                                                        '&'],
                                                                  'returnStatus': ['*']},
                                               'types': {'referenceFileName': 'MString'}}],
                          'unloadReferenceByNode': [{'argInfo': {'referenceNodeName': {'doc': 'MString containing the name of the reference node. ',
                                                                                       'type': 'MString'}},
                                                     'args': [('referenceNodeName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nUnloads the reference, referenced by the given reference node.',
                                                     'inArgs': ['referenceNodeName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The name of the unloaded reference file',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': True,
                                                     'typeQualifiers': {'referenceNodeName': ['const',
                                                                                              '&'],
                                                                        'returnStatus': ['*']},
                                                     'types': {'referenceNodeName': 'MString'}},
                                                    {'argInfo': {'referenceNode': {'doc': 'MObject containing the reference node. ',
                                                                                   'type': 'MObject'}},
                                                     'args': [('referenceNode',
                                                               'MObject',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nUnloads the reference, referenced by the given reference node.',
                                                     'inArgs': ['referenceNode'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The name of the unloaded reference file',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': True,
                                                     'typeQualifiers': {'referenceNode': ['&'],
                                                                        'returnStatus': ['*']},
                                                     'types': {'referenceNode': 'MObject'}}]},
              'pymelEnums': {'ExportType': "Enum('ExportType', [('all', 0), ('kExportTypeAll', 0), ('selected', 1), ('kExportTypeSelected', 1), ('anim', 2), ('kExportTypeAnim', 2), ('animFromReference', 3), ('kExportTypeAnimFromReference', 3), ('asReference', 4), ('kExportTypeAsReference', 4), ('edits', 5), ('kExportTypeEdits', 5), ('prefObjects', 6), ('kExportTypePrefObjects', 6)], multiKeys=True)",
                             'NamespaceMergeMethod': "Enum('NamespaceMergeMethod', [('removeNamespaceIfEmpty', 0), ('kRemoveNamespaceIfEmpty', 0), ('mergeNamespaceWithRootNamespace', 1), ('kMergeNamespaceWithRootNamespace', 1), ('mergeNamespaceWithParentNamespace', 2), ('kMergeNamespaceWithParentNamespace', 2), ('forceDeleteNamespaceContent', 3), ('kForceDeleteNamespaceContent', 3)], multiKeys=True)",
                             'ReferenceMode': "Enum('ReferenceMode', [('default', 0), ('kLoadDefault', 0), ('allReferences', 1), ('kLoadAllReferences', 1), ('noReferences', 2), ('kLoadNoReferences', 2)], multiKeys=True)"},
              'pymelMethods': {'currentFile': 'getCurrentFile',
                               'mustRenameToSave': 'getMustRenameToSave',
                               'mustRenameToSaveMsg': 'getMustRenameToSaveMsg'}},
  'MFileObject': {'enums': {'MFileResolveMethod': {'valueDocs': {'baseName': 'Strips away everything but the base file name and look in the current workspace.',
                                                                 'dirMap': 'Checks path against mappings defined with the dirmap command. Only for absolute paths.',
                                                                 'exact': "Checks if expanded paths exist. If paths are relative, assume it's relative to the current workspace (so check workspace current directory, file-rule directory and root directory)",
                                                                 'inputFile': 'This mode is the default on file open and import, and is suitable for files that are to be used as input files. The file will be checked for existence.',
                                                                 'inputReference': 'This mode is the default on file reference. In addition to the checks done for a regular input file, it will also check the reference mappings.',
                                                                 'kBaseName': 'Strips away everything but the base file name and look in the current workspace.',
                                                                 'kDirMap': 'Checks path against mappings defined with the dirmap command. Only for absolute paths.',
                                                                 'kExact': "Checks if expanded paths exist. If paths are relative, assume it's relative to the current workspace (so check workspace current directory, file-rule directory and root directory)",
                                                                 'kInputFile': 'This mode is the default on file open and import, and is suitable for files that are to be used as input files. The file will be checked for existence.',
                                                                 'kInputReference': 'This mode is the default on file reference. In addition to the checks done for a regular input file, it will also check the reference mappings.',
                                                                 'kNone': '(Default) The resolved path is simply the resulting path after converting the raw value to its expanded form. If the path contains environment variables, the resolved value will be the first path returned from their expansion. Relative paths will be considered to be relative to root of the current project. The resolution algorithm will not check if this file actually exists - the resolution will be considered successful whether it exists or not. With this mode, the resolver will not continue on to attempt to resolve using any other resolve method. The user must explicitly check',
                                                                 'kReferenceMappings': 'Check path against any previously re-mapped reference locations. If kRelative/kBaseName are set, then even if we have an absolute path, convert to relative and/or baseName and look for them in directories provided to the missing reference dialog.',
                                                                 'kRelative': 'Strips away the project directory, and treats path as relative. Relative to the current workspace, that is. So look in the workspace current directory, file-rules directory and the root directory',
                                                                 'kStrict': 'Equivalent to the file -strict flag.',
                                                                 'none': '(Default) The resolved path is simply the resulting path after converting the raw value to its expanded form. If the path contains environment variables, the resolved value will be the first path returned from their expansion. Relative paths will be considered to be relative to root of the current project. The resolution algorithm will not check if this file actually exists - the resolution will be considered successful whether it exists or not. With this mode, the resolver will not continue on to attempt to resolve using any other resolve method. The user must explicitly check',
                                                                 'referenceMappings': 'Check path against any previously re-mapped reference locations. If kRelative/kBaseName are set, then even if we have an absolute path, convert to relative and/or baseName and look for them in directories provided to the missing reference dialog.',
                                                                 'relative': 'Strips away the project directory, and treats path as relative. Relative to the current workspace, that is. So look in the workspace current directory, file-rules directory and the root directory',
                                                                 'strict': 'Equivalent to the file -strict flag.'},
                                                   'values': "Enum('MFileResolveMethod', {'kNone': 1, 'kExact': 2, 'kDirMap': 4, 'kStrict': 6, 'kReferenceMappings': 8, 'kRelative': 16, 'kBaseName': 32, 'kInputFile': 54, 'kInputReference': 62})"}},
                  'invertibles': [('setRawFullName', 'rawFullName'),
                                  ('setResolveMethod', 'resolveMethod'),
                                  ('setName', 'name'),
                                  ('setRawURI', 'rawURI'),
                                  ('setRawPath', 'rawPath'),
                                  ('setRawName', 'rawName'),
                                  ('setFullName', 'fullName')],
                  'methods': {'exists': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nChecks to see if the file returned by the fullName method exists and is readable.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}},
                                         {'argInfo': {'index': {'doc': 'Index of the path element to be used in searching for the file.',
                                                                'type': 'uint'}},
                                          'args': [('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nChecks to see if the file constructed from the indicated portion of the path element and filename element exists and is readable.',
                                          'inArgs': ['index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'true if the file exists and is readable, false otherwise. ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'index': ['unsigned']},
                                          'types': {'index': 'uint'}}],
                              'expandedFullName': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nReturns the pathname of a file constructed from the unresolved  MFileObject  values. The file name will consist of the the expanded raw path and raw name elements. All variables in the path element are expanded, and the first path (the part before the first separator (':') in the path) is prepended to the filename element to construct the fullName.",
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                              'expandedPath': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the raw path element of the unresolved  MFileObject  with all environment variables expanded. In the case that the path expands to multiple paths, the first expanded path will be returned.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'fullName': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': True,
                                            'doc': '\n This method is obsolete. \n',
                                            'inArgs': [],
                                            'inverse': ('setFullName',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The expanded filename. ',
                                                           'qualifiers': [],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'getResolvedFullName': [{'argInfo': {'rawFullName': {'doc': 'The fully specified unresolved path',
                                                                                   'type': 'MString'}},
                                                       'args': [('rawFullName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis is a static convenience method for performing a straightforward resolve of a file path.',
                                                       'inArgs': ['rawFullName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The full path to the resolved file, or an empty string if the resolution was unsuccessful. ',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': True,
                                                       'typeQualifiers': {'rawFullName': ['const',
                                                                                          '&']},
                                                       'types': {'rawFullName': 'MString'}},
                                                      {'argInfo': {'exists': {'doc': 'Set on return to indicate if the resolved path exists or not ',
                                                                              'type': 'bool'},
                                                                   'rawFullName': {'doc': 'The fully specified unresolved path ',
                                                                                   'type': 'MString'},
                                                                   'resolveMethod': {'doc': '(optional) set by caller to override the resolve method used (default MFileObject::kNone)',
                                                                                     'type': ('MFileObject',
                                                                                              'MFileResolveMethod')}},
                                                       'args': [('rawFullName',
                                                                 'MString',
                                                                 'in'),
                                                                ('exists',
                                                                 'bool',
                                                                 'out'),
                                                                ('resolveMethod',
                                                                 ('MFileObject',
                                                                  'MFileResolveMethod'),
                                                                 'in')],
                                                       'defaults': {'resolveMethod': ('MFileObject',
                                                                                      'MFileResolveMethod',
                                                                                      'kNone')},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis is a static convenience method for performing a straightforward resolve of a file path.',
                                                       'inArgs': ['rawFullName',
                                                                  'resolveMethod'],
                                                       'outArgs': ['exists'],
                                                       'returnInfo': {'doc': 'The full path to the resolved file, or an empty string if the resolution was unsuccessful. ',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': True,
                                                       'typeQualifiers': {'exists': ['&'],
                                                                          'rawFullName': ['const',
                                                                                          '&'],
                                                                          'resolveMethod': []},
                                                       'types': {'exists': 'bool',
                                                                 'rawFullName': 'MString',
                                                                 'resolveMethod': ('MFileObject',
                                                                                   'MFileResolveMethod')}}],
                              'isAbsolutePath': [{'argInfo': {'fileName': {'doc': 'the string used to check if it is absolute',
                                                                           'type': 'MString'}},
                                                  'args': [('fileName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nUtility method which checks a file path string and determines if it represents an absolute file path. An absolute path can uniquely identify a directory or file.',
                                                  'inArgs': ['fileName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'True if fileName is an absolute path ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': True,
                                                  'typeQualifiers': {'fileName': ['const',
                                                                                  '&']},
                                                  'types': {'fileName': 'MString'}}],
                              'isSet': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nChecks to see if both file and path elements of the  MFileObject  have been set.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'ithFullName': [{'argInfo': {'index': {'doc': 'the index of the desired path portion.',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the pathname of a file constructed from the indicated portion of the path element and filename element. All variables in the path element are expanded, and the indicated path portion is prepended to the filename element to construct the fullName.',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The pathname. ',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                              'ithPath': [{'argInfo': {'index': {'doc': 'the index of the desired path portion.',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the indicated portion of the path element of the  MFileObject . All variables in the path element are expanded, and the portion indicated by the argument is extracted and returned.',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The path element. ',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned']},
                                           'types': {'index': 'uint'}}],
                              'name': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': [],
                                        'inverse': ('setName', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The resolved filename. ',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'overrideResolvedFullName': [{'argInfo': {'fullFileName': {'doc': 'the string used to override the path and filename.',
                                                                                         'type': 'MString'}},
                                                            'args': [('fullFileName',
                                                                      'MString',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nNormally when a raw file name is set, Maya will perform a series of operations on it in an attempt to resolve it to a valid file name. This final resolved file name can be accessed through the  MFileObject::resolvedName() ,  MFileObject::resolvedPath() , and MFileObject::resolvedFullFileName() methods and can be quite different from the originally specified raw file name.',
                                                            'inArgs': ['fullFileName'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'fullFileName': ['const',
                                                                                                '&']},
                                                            'types': {'fullFileName': 'MString'}}],
                              'path': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The expanded path. ',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'pathCount': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nReturns the number of paths in the path element of the  MFileObject . This will be equal to one more than the number of ':' characters specified by the setRawPath method.",
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'rawFullName': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the unresolved full file name (path plus filename) of the  MFileObject  with all environment variables unexpanded.',
                                               'inArgs': [],
                                               'inverse': ('setRawFullName',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'rawName': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the unresolved filename element of the  MFileObject .',
                                           'inArgs': [],
                                           'inverse': ('setRawName',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'rawPath': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the path element of the  MFileObject  with all environment variables unexpanded.',
                                           'inArgs': [],
                                           'inverse': ('setRawPath',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'rawURI': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the unresolved URI of the  MFileObject , if any.',
                                          'inArgs': [],
                                          'inverse': ('setRawURI', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'MURI'},
                                          'returnType': 'MURI',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'resolveMethod': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the file-path resolution steps this object will use',
                                                 'inArgs': [],
                                                 'inverse': ('setResolveMethod',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MFileObject',
                                                                         'MFileResolveMethod')},
                                                 'returnType': ('MFileObject',
                                                                'MFileResolveMethod'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'resolvedFullName': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nReturns the first pathname of a file constructed from the path and filename elements. All variables in the path element are expanded, and the first path (the part before the first ':' in the path) is prepended to the filename element. After expanding all environment variables Maya may then perform additional modifications, such as prepending directories to a relative path name, in order to resolve the path to a valid location on disk.",
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                              'resolvedName': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the resolved filename element of the  MFileObject .',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'resolvedPath': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the resolved path element of the  MFileObject . In order to build the resolved path, Maya first expands all environment variables and then may perform additional modifications, such as prepending directories to a relative path name, in order to resolve the path to a valid location on disk.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The resolved path. ',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'setFullName': [{'argInfo': {'fileName': {'doc': 'the string used to initialize the path and filename.',
                                                                        'type': 'MString'}},
                                               'args': [('fileName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': True,
                                               'doc': '\n This method is obsolete. \n',
                                               'inArgs': ['fileName'],
                                               'inverse': ('fullName',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'fileName': ['const',
                                                                               '&']},
                                               'types': {'fileName': 'MString'}}],
                              'setName': [{'argInfo': {'fileName': {'doc': 'The filename.',
                                                                    'type': 'MString'}},
                                           'args': [('fileName',
                                                     'MString',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': '\n This method is obsolete. \n',
                                           'inArgs': ['fileName'],
                                           'inverse': ('name', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'fileName': ['const',
                                                                           '&']},
                                           'types': {'fileName': 'MString'}}],
                              'setRawFullName': [{'argInfo': {'fullFileName': {'doc': 'the string used to initialize the path and filename.',
                                                                               'type': 'MString'}},
                                                  'args': [('fullFileName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method combines the functions of the setRawName and setRawPath methods in that it sets both the path and filename from the given name.',
                                                  'inArgs': ['fullFileName'],
                                                  'inverse': ('rawFullName',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'fullFileName': ['const',
                                                                                      '&']},
                                                  'types': {'fullFileName': 'MString'}}],
                              'setRawName': [{'argInfo': {'fileName': {'doc': 'The filename to set.',
                                                                       'type': 'MString'}},
                                              'args': [('fileName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nSet the unresolved filename element of the  MFileObject  instance. This name should not contain any '/' characters, it should indicate simply the name of a file. The directories in which this name will be searched for are specified by setRawPath.",
                                              'inArgs': ['fileName'],
                                              'inverse': ('rawName',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'fileName': ['const',
                                                                              '&']},
                                              'types': {'fileName': 'MString'}}],
                              'setRawPath': [{'argInfo': {'pathName': {'doc': 'The path string.',
                                                                       'type': 'MString'}},
                                              'args': [('pathName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nSet the unresolved path element of the  MFileObject  instance. This should contain a list of directories, each separated by a single ':' character. The pathnames can contain Unix environment variables in the form $VARNAME. These will be expanded when paths to actual filenames are constructed.",
                                              'inArgs': ['pathName'],
                                              'inverse': ('rawPath',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'pathName': ['const',
                                                                              '&']},
                                              'types': {'pathName': 'MString'}}],
                              'setRawURI': [{'argInfo': {'uri': {'doc': 'The URI string.',
                                                                 'type': 'MString'}},
                                             'args': [('uri',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the unresolved URI of the  MFileObject  instance from a string.',
                                             'inArgs': ['uri'],
                                             'inverse': ('rawURI', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'uri': ['const',
                                                                        '&']},
                                             'types': {'uri': 'MString'}},
                                            {'argInfo': {'uri': {'doc': 'The URI object.',
                                                                 'type': 'MURI'}},
                                             'args': [('uri',
                                                       'MURI',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the unresolved URI of the  MFileObject  instance.',
                                             'inArgs': ['uri'],
                                             'inverse': ('rawURI', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'uri': ['const',
                                                                        '&']},
                                             'types': {'uri': 'MURI'}}],
                              'setResolveMethod': [{'argInfo': {'method': {'doc': 'Structure indicating how to resolve the file path. ',
                                                                           'type': ('MFileObject',
                                                                                    'MFileResolveMethod')}},
                                                    'args': [('method',
                                                              ('MFileObject',
                                                               'MFileResolveMethod'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the steps that should be used to resolve this file path.',
                                                    'inArgs': ['method'],
                                                    'inverse': ('resolveMethod',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'method': []},
                                                    'types': {'method': ('MFileObject',
                                                                         'MFileResolveMethod')}}]},
                  'pymelEnums': {'MFileResolveMethod': "Enum('MFileResolveMethod', [('none', 1), ('kNone', 1), ('exact', 2), ('kExact', 2), ('dirMap', 4), ('kDirMap', 4), ('strict', 6), ('kStrict', 6), ('referenceMappings', 8), ('kReferenceMappings', 8), ('relative', 16), ('kRelative', 16), ('baseName', 32), ('kBaseName', 32), ('inputFile', 54), ('kInputFile', 54), ('inputReference', 62), ('kInputReference', 62)], multiKeys=True)"},
                  'pymelMethods': {'fullName': 'getFullName',
                                   'name': 'getName',
                                   'rawFullName': 'getRawFullName',
                                   'rawName': 'getRawName',
                                   'rawPath': 'getRawPath',
                                   'rawURI': 'getRawURI',
                                   'resolveMethod': 'getResolveMethod'}},
  'MFloatArray': {'enums': {},
                  'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                  ('setLength', 'length')],
                  'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the indicated element. ',
                                                              'qualifiers': [],
                                                              'type': 'float'},
                                               'returnType': 'float',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}},
                                              {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the indicated element ',
                                                              'qualifiers': ['&'],
                                                              'type': 'float'},
                                               'returnType': 'float',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                              'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                  'type': 'float'}},
                                          'args': [('element',
                                                    'float',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': []},
                                          'types': {'element': 'float'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'clear': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                               'type': 'MFloatArray'}},
                                        'args': [('source',
                                                  'MFloatArray',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopy the contents of the source array to this array.',
                                        'inArgs': ['source'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'source': ['const',
                                                                      '&']},
                                        'types': {'source': 'MFloatArray'}}],
                              'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                             'type': 'float__array'}},
                                       'args': [('array',
                                                 'float__array',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the elements of the array into the given C++ array of floats. No checking is done to ensure that the destination C++ array of floats is large enough to hold all the elements of the instance.',
                                       'inArgs': [],
                                       'outArgs': ['array'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'array': []},
                                       'types': {'array': 'float__array'}},
                                      {'argInfo': {'array': {'doc': 'the array to populate',
                                                             'type': 'double__array'}},
                                       'args': [('array',
                                                 'double__array',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the elements of the array into the given C++ array of doubles. No checking is done to ensure that the destination C++ array of doubles is large enough to hold all the elements of the instance.',
                                       'inArgs': [],
                                       'outArgs': ['array'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'array': []},
                                       'types': {'array': 'double__array'}}],
                              'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                  'type': 'float'},
                                                      'index': {'doc': 'the index of the element to set to the the new value',
                                                                'type': 'uint'}},
                                          'args': [('element',
                                                    'float',
                                                    'in'),
                                                   ('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element', 'index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': [],
                                                             'index': ['unsigned']},
                                          'types': {'element': 'float',
                                                    'index': 'uint'}}],
                              'length': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the number of elements in the instance.',
                                          'inArgs': [],
                                          'inverse': ('setLength', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The number of elements in the instance ',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                'type': 'uint'}},
                                          'args': [('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                          'inArgs': ['index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'index': ['unsigned']},
                                          'types': {'index': 'uint'}}],
                              'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                               'type': 'float'},
                                                   'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'}},
                                       'args': [('element',
                                                 'float',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated float value.',
                                       'inArgs': ['element', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'element': [],
                                                          'index': ['unsigned']},
                                       'types': {'element': 'float',
                                                 'index': 'uint'}},
                                      {'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                               'type': 'double'},
                                                   'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'}},
                                       'args': [('element',
                                                 'double',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated double value.',
                                       'inArgs': ['element', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'element': [],
                                                          'index': ['unsigned']},
                                       'types': {'element': 'double',
                                                 'index': 'uint'}}],
                              'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                    'type': 'uint'}},
                                             'args': [('length',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                             'inArgs': ['length'],
                                             'inverse': ('length', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'length': ['unsigned']},
                                             'types': {'length': 'uint'}}],
                              'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                 'type': 'uint'}},
                                                    'args': [('newIncrement',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                    'inArgs': ['newIncrement'],
                                                    'inverse': ('sizeIncrement',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'newIncrement': ['unsigned']},
                                                    'types': {'newIncrement': 'uint'}}],
                              'sizeIncrement': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                 'inArgs': [],
                                                 'inverse': ('setSizeIncrement',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'length': 'getLength',
                                   'sizeIncrement': 'getSizeIncrement'}},
  'MFloatMatrix': {'enums': {},
                   'methods': {'__add__': [{'argInfo': {'right': {'doc': 'Matrix to add. ',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe matrix addition operator.  Parameters: \n \n [in]  right  Matrix to add.  \n \n \n Returns: Sum of both matrices.  \n',
                                            'inArgs': ['right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Sum of both matrices. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {'right': ['const',
                                                                         '&']},
                                            'types': {'right': 'MFloatMatrix'}}],
                               '__eq__': [{'argInfo': {'other': {'doc': 'Matrix to test with. ',
                                                                 'type': 'MFloatMatrix'}},
                                           'args': [('other',
                                                     'MFloatMatrix',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe matrix equality operator.  Parameters: \n \n [in]  other  Matrix to test with.  \n \n \n Returns: True is the matrices are identical.  \n',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'True is the matrices are identical. ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MFloatMatrix'}}],
                               '__getitem__': [{'argInfo': {'row': {'doc': 'index of the row to access',
                                                                    'type': 'uint'}},
                                                'args': [('row',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nIndex operator. Returns an entire row of the matrix as an array of floats.',
                                                'inArgs': ['row'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' float array containing the values of the specified row   ',
                                                               'qualifiers': ['*'],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {'row': ['unsigned']},
                                                'types': {'row': 'uint'}},
                                               {'argInfo': {'row': {'doc': 'index of the row to access',
                                                                    'type': 'uint'}},
                                                'args': [('row',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                'inArgs': ['row'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' float array containing the values of the specified row   ',
                                                               'qualifiers': ['*'],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {'row': ['unsigned']},
                                                'types': {'row': 'uint'}}],
                               '__iadd__': [{'argInfo': {'right': {'doc': 'Matrix to add. ',
                                                                   'type': 'MFloatMatrix'}},
                                             'args': [('right',
                                                       'MFloatMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place matrix addition operator.  Parameters: \n \n [in]  right  Matrix to add.  \n \n \n Returns: A reference to the result.  \n',
                                             'inArgs': ['right'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the result. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatMatrix'},
                                             'returnType': 'MFloatMatrix',
                                             'static': False,
                                             'typeQualifiers': {'right': ['const',
                                                                          '&']},
                                             'types': {'right': 'MFloatMatrix'}}],
                               '__imul__': [{'argInfo': {'right': {'doc': 'Matrix to multiply. ',
                                                                   'type': 'MFloatMatrix'}},
                                             'args': [('right',
                                                       'MFloatMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place matrix multiplication operator.  Parameters: \n \n [in]  right  Matrix to multiply.  \n \n \n Returns: A reference to the result.  \n',
                                             'inArgs': ['right'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the result. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatMatrix'},
                                             'returnType': 'MFloatMatrix',
                                             'static': False,
                                             'typeQualifiers': {'right': ['const',
                                                                          '&']},
                                             'types': {'right': 'MFloatMatrix'}},
                                            {'argInfo': {'factor': {'doc': 'scaling factor. ',
                                                                    'type': 'float'}},
                                             'args': [('factor',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place matrix multiply by a scalar operator.  Parameters: \n \n [in]  factor  scaling factor.  \n \n \n Returns: A reference to the result.  \n',
                                             'inArgs': ['factor'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the result. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatMatrix'},
                                             'returnType': 'MFloatMatrix',
                                             'static': False,
                                             'typeQualifiers': {'factor': []},
                                             'types': {'factor': 'float'}}],
                               '__isub__': [{'argInfo': {'right': {'doc': 'Matrix to subtract. ',
                                                                   'type': 'MFloatMatrix'}},
                                             'args': [('right',
                                                       'MFloatMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place matrix subtraction operator.  Parameters: \n \n [in]  right  Matrix to subtract.  \n \n \n Returns: A reference to the result.  \n',
                                             'inArgs': ['right'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the result. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatMatrix'},
                                             'returnType': 'MFloatMatrix',
                                             'static': False,
                                             'typeQualifiers': {'right': ['const',
                                                                          '&']},
                                             'types': {'right': 'MFloatMatrix'}}],
                               '__mul__': [{'argInfo': {'right': {'doc': 'Matrix to multiply. ',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe matrix multiplication operator.  Parameters: \n \n [in]  right  Matrix to multiply.  \n \n \n Returns: Product of both matrices.  \n',
                                            'inArgs': ['right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Product of both matrices. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {'right': ['const',
                                                                         '&']},
                                            'types': {'right': 'MFloatMatrix'}},
                                           {'argInfo': {'factor': {'doc': 'Scaling factor. ',
                                                                   'type': 'float'}},
                                            'args': [('factor',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe matrix multiply by a scalar operator.  Parameters: \n \n [in]  factor  Scaling factor.  \n \n \n Returns: Scaled matrix.  \n',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled matrix. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {'factor': []},
                                            'types': {'factor': 'float'}},
                                           {'argInfo': {'factor': {'doc': 'Scaling factor. ',
                                                                   'type': 'float'},
                                                        'right': {'doc': 'Matrix to multiply. ',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('factor',
                                                      'float',
                                                      'in'),
                                                     ('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['factor', 'right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled matrix. ',
                                                           'qualifiers': ['MFloatMatrix'],
                                                           'type': ('MFloatMatrix',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatMatrix',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'factor': [],
                                                               'right': ['const',
                                                                         '&']},
                                            'types': {'factor': 'float',
                                                      'right': 'MFloatMatrix'}}],
                               '__ne__': [{'argInfo': {'other': {'doc': 'Matrix to test with. ',
                                                                 'type': 'MFloatMatrix'}},
                                           'args': [('other',
                                                     'MFloatMatrix',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe matrix inequality operator.  Parameters: \n \n [in]  other  Matrix to test with.  \n \n \n Returns: True is the matrices are not identical.  \n',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'True is the matrices are not identical. ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MFloatMatrix'}}],
                               '__sub__': [{'argInfo': {'right': {'doc': 'Matrix to subtract. ',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe matrix subtraction operator.  Parameters: \n \n [in]  right  Matrix to subtract.  \n \n \n Returns: Difference of both matrices.  \n',
                                            'inArgs': ['right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Difference of both matrices. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {'right': ['const',
                                                                         '&']},
                                            'types': {'right': 'MFloatMatrix'}}],
                               'adjoint': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCompute and return the adjoint of this instance.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'det3x3': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nCompute and return the determinant of the upper left 3x3 submatrix of this instance.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'det4x4': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nCompute and return the determinant of this instance.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'get': [{'argInfo': {'dest': {'doc': 'the 4x4 matrix of doubles to populate',
                                                             'type': 'double__array4'}},
                                        'args': [('dest',
                                                  'double__array4',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nFill a 4x4 matrix of doubles with the elements from the instance.',
                                        'inArgs': [],
                                        'outArgs': ['dest'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'dest': []},
                                        'types': {'dest': 'double__array4'}},
                                       {'argInfo': {'dest': {'doc': 'The 4x4 matrix of floats to populate.',
                                                             'type': 'float__array4'}},
                                        'args': [('dest',
                                                  'float__array4',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nFill a 4x4 matrix of floats with the elements from the instance.',
                                        'inArgs': [],
                                        'outArgs': ['dest'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'dest': []},
                                        'types': {'dest': 'float__array4'}}],
                               'homogenize': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nCompute and return a homogenized version of this instance.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MFloatMatrix'},
                                               'returnType': 'MFloatMatrix',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'inverse': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCompute and return the inverse of this instance.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                               'isEquivalent': [{'argInfo': {'other': {'doc': 'the matrix to compare to ',
                                                                       'type': 'MFloatMatrix'},
                                                             'tolerance': {'doc': 'the tolerance to use during the comparison',
                                                                           'type': 'float'}},
                                                 'args': [('other',
                                                           'MFloatMatrix',
                                                           'in'),
                                                          ('tolerance',
                                                           'float',
                                                           'in')],
                                                 'defaults': {'tolerance': 1e-05},
                                                 'deprecated': False,
                                                 'doc': '\r\nDetermine if the given matrix is equivalent to this instance within the specified tolerance.',
                                                 'inArgs': ['other',
                                                            'tolerance'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'True if the matrices are equivalent and false otherwise ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'other': ['const',
                                                                              '&'],
                                                                    'tolerance': []},
                                                 'types': {'other': 'MFloatMatrix',
                                                           'tolerance': 'float'}}],
                               'setToIdentity': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet this instance to the 4x4 identity matrix.  Returns: A reference to this matrix.  \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['&'],
                                                                 'type': 'MFloatMatrix'},
                                                  'returnType': 'MFloatMatrix',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'setToProduct': [{'argInfo': {'left': {'doc': 'The left hand matrix for the operation ',
                                                                      'type': 'MFloatMatrix'},
                                                             'right': {'doc': 'The right hand matrix for the operation ',
                                                                       'type': 'MFloatMatrix'}},
                                                 'args': [('left',
                                                           'MFloatMatrix',
                                                           'in'),
                                                          ('right',
                                                           'MFloatMatrix',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet this instance to the inner product of the two argument matrices.',
                                                 'inArgs': ['left',
                                                            'right'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A reference to the result. ',
                                                                'qualifiers': ['&'],
                                                                'type': 'MFloatMatrix'},
                                                 'returnType': 'MFloatMatrix',
                                                 'static': False,
                                                 'typeQualifiers': {'left': ['const',
                                                                             '&'],
                                                                    'right': ['const',
                                                                              '&']},
                                                 'types': {'left': 'MFloatMatrix',
                                                           'right': 'MFloatMatrix'}}],
                               'transpose': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nCompute and return the transpose of this instance.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MFloatMatrix'},
                                              'returnType': 'MFloatMatrix',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                   'pymelEnums': {}},
  'MFloatPoint': {'enums': {},
                  'methods': {'[static]': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nA constant representing the origin - (0,0,0,1). \r\n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['MFloatPoint::origin'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              '__add__': [{'argInfo': {'other': {'doc': 'The vector to add. ',
                                                                 'type': 'MFloatVector'}},
                                           'args': [('other',
                                                     'MFloatVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe operator for adding an  MFloatVector  to an  MFloatPoint . A new point is returned whose position is that of the original point translated by the vector.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MFloatVector'}}],
                              '__div__': [{'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                                 'type': 'float'}},
                                           'args': [('scale',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe division operator that allows the vector to by scaled by the given float parameter. The x, y, and z components are each divided by the parameter. The w component remains unchanged.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Scaled point. ',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'scale': ['const']},
                                           'types': {'scale': 'float'}}],
                              '__eq__': [{'argInfo': {'other': {'doc': 'The point to compare with. ',
                                                                'type': 'MFloatPoint'}},
                                          'args': [('other',
                                                    'MFloatPoint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThe equality operator. Returns true if all of the x, y, z, and w components of the two points are identical.',
                                          'inArgs': ['other'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'other': ['const',
                                                                       '&']},
                                          'types': {'other': 'MFloatPoint'}}],
                              '__getitem__': [{'argInfo': {'i': {'doc': 'value indicating which component to return',
                                                                 'type': 'uint'}},
                                               'args': [('i',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThe index operator.  \n If the argument is 0 it will return the x component of the constant instance.  \n If the argument is 1 it will return the y component of the constant instance.  \n If the argument is 2 it will return the z component of the constant instance.  \n If the argument is 3 it will return the w component of the constant instance. Otherwise it will return the x component of the point. \n \n Parameters: \n \n [in]  i  value indicating which component to return \n \n \n Returns: The value of the indicated component of the instance.  \n',
                                               'inArgs': ['i'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the indicated component of the instance. ',
                                                              'qualifiers': [],
                                                              'type': 'float'},
                                               'returnType': 'float',
                                               'static': False,
                                               'typeQualifiers': {'i': ['unsigned']},
                                               'types': {'i': 'uint'}},
                                              {'argInfo': {'i': {'doc': 'value indicating which component to return',
                                                                 'type': 'uint'}},
                                               'args': [('i',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                               'inArgs': ['i'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the indicated component of the instance. ',
                                                              'qualifiers': ['&'],
                                                              'type': 'float'},
                                               'returnType': 'float',
                                               'static': False,
                                               'typeQualifiers': {'i': ['unsigned']},
                                               'types': {'i': 'uint'}}],
                              '__iadd__': [{'argInfo': {'vector': {'doc': 'The vector to add. ',
                                                                   'type': 'MFloatVector'}},
                                            'args': [('vector',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place addition operator for adding an  MFloatVector  to an  MFloatPoint . The current instance is translated from its original position by the vector.',
                                            'inArgs': ['vector'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'vector': ['const',
                                                                          '&']},
                                            'types': {'vector': 'MFloatVector'}}],
                              '__imul__': [{'argInfo': {'right': {'doc': 'the MFloatMatrix to right multiply by',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place multiplication operator for computing the product of this point instance with the given matrix.',
                                            'inArgs': ['right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A point representing the product ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'right': ['const',
                                                                         '&']},
                                            'types': {'right': 'MFloatMatrix'}},
                                           {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                                   'type': 'int'}},
                                            'args': [('factor',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'This point. ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'factor': ['const']},
                                            'types': {'factor': 'int'}},
                                           {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                                   'type': 'short'}},
                                            'args': [('factor',
                                                      'short',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'This point. ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'factor': ['const']},
                                            'types': {'factor': 'short'}},
                                           {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                                   'type': 'uint'}},
                                            'args': [('factor',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'This point. ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'factor': ['const',
                                                                          'unsigned']},
                                            'types': {'factor': 'uint'}},
                                           {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                                   'type': 'short'}},
                                            'args': [('factor',
                                                      'short',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'This point. ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'factor': ['const',
                                                                          'unsigned']},
                                            'types': {'factor': 'short'}},
                                           {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                                   'type': 'float'}},
                                            'args': [('factor',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'This point. ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'factor': ['const']},
                                            'types': {'factor': 'float'}},
                                           {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                                   'type': 'double'}},
                                            'args': [('factor',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'This point. ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'factor': ['const']},
                                            'types': {'factor': 'double'}}],
                              '__isub__': [{'argInfo': {'vector': {'doc': 'The vector to substract. ',
                                                                   'type': 'MFloatVector'}},
                                            'args': [('vector',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in-place subtraction operator for subtracting an  MFloatVector  from an  MFloatPoint . The current instance is translated from its original position by the inverse of the vector.',
                                            'inArgs': ['vector'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['&'],
                                                           'type': 'MFloatPoint'},
                                            'returnType': 'MFloatPoint',
                                            'static': False,
                                            'typeQualifiers': {'vector': ['const',
                                                                          '&']},
                                            'types': {'vector': 'MFloatVector'}}],
                              '__mul__': [{'argInfo': {'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'int'}},
                                           'args': [('scale',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'scale': ['const']},
                                           'types': {'scale': 'int'}},
                                          {'argInfo': {'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'short'}},
                                           'args': [('scale',
                                                     'short',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'scale': ['const']},
                                           'types': {'scale': 'short'}},
                                          {'argInfo': {'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'uint'}},
                                           'args': [('scale',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'scale': ['const',
                                                                        'unsigned']},
                                           'types': {'scale': 'uint'}},
                                          {'argInfo': {'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'short'}},
                                           'args': [('scale',
                                                     'short',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'scale': ['const',
                                                                        'unsigned']},
                                           'types': {'scale': 'short'}},
                                          {'argInfo': {'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'float'}},
                                           'args': [('scale',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given float parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'scale': ['const']},
                                           'types': {'scale': 'float'}},
                                          {'argInfo': {'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'double'}},
                                           'args': [('scale',
                                                     'double',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'scale': ['const']},
                                           'types': {'scale': 'double'}},
                                          {'argInfo': {'right': {'doc': 'the MFloatMatrix to right multiply by',
                                                                 'type': 'MFloatMatrix'}},
                                           'args': [('right',
                                                     'MFloatMatrix',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe multiplication operator for computing the product of this point instance with the given matrix.',
                                           'inArgs': ['right'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A point representing the product ',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'right': ['const',
                                                                        '&']},
                                           'types': {'right': 'MFloatMatrix'}},
                                          {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                             'type': 'MFloatPoint'},
                                                       'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'int'}},
                                           'args': [('scale',
                                                     'int',
                                                     'in'),
                                                    ('p',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['scale', 'p'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                          'qualifiers': ['MFloatPoint'],
                                                          'type': ('MFloatPoint',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MFloatPoint',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'p': ['const',
                                                                    '&'],
                                                              'scale': []},
                                           'types': {'p': 'MFloatPoint',
                                                     'scale': 'int'}},
                                          {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                             'type': 'MFloatPoint'},
                                                       'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'short'}},
                                           'args': [('scale',
                                                     'short',
                                                     'in'),
                                                    ('p',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['scale', 'p'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                          'qualifiers': ['MFloatPoint'],
                                                          'type': ('MFloatPoint',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MFloatPoint',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'p': ['const',
                                                                    '&'],
                                                              'scale': []},
                                           'types': {'p': 'MFloatPoint',
                                                     'scale': 'short'}},
                                          {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                             'type': 'MFloatPoint'},
                                                       'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'uint'}},
                                           'args': [('scale',
                                                     'uint',
                                                     'in'),
                                                    ('p',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['scale', 'p'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                          'qualifiers': ['MFloatPoint'],
                                                          'type': ('MFloatPoint',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MFloatPoint',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'p': ['const',
                                                                    '&'],
                                                              'scale': ['unsigned']},
                                           'types': {'p': 'MFloatPoint',
                                                     'scale': 'uint'}},
                                          {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                             'type': 'MFloatPoint'},
                                                       'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'short'}},
                                           'args': [('scale',
                                                     'short',
                                                     'in'),
                                                    ('p',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['scale', 'p'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                          'qualifiers': ['MFloatPoint'],
                                                          'type': ('MFloatPoint',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MFloatPoint',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'p': ['const',
                                                                    '&'],
                                                              'scale': ['unsigned']},
                                           'types': {'p': 'MFloatPoint',
                                                     'scale': 'short'}},
                                          {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                             'type': 'MFloatPoint'},
                                                       'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'float'}},
                                           'args': [('scale',
                                                     'float',
                                                     'in'),
                                                    ('p',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['scale', 'p'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                          'qualifiers': ['MFloatPoint'],
                                                          'type': ('MFloatPoint',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MFloatPoint',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'p': ['const',
                                                                    '&'],
                                                              'scale': []},
                                           'types': {'p': 'MFloatPoint',
                                                     'scale': 'float'}},
                                          {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                             'type': 'MFloatPoint'},
                                                       'scale': {'doc': 'The scale parameter. ',
                                                                 'type': 'double'}},
                                           'args': [('scale',
                                                     'double',
                                                     'in'),
                                                    ('p',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['scale', 'p'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                          'qualifiers': ['MFloatPoint'],
                                                          'type': ('MFloatPoint',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MFloatPoint',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'p': ['const',
                                                                    '&'],
                                                              'scale': []},
                                           'types': {'p': 'MFloatPoint',
                                                     'scale': 'double'}},
                                          {'argInfo': {'left': {'doc': 'the MFloatMatrix to right multiply by ',
                                                                'type': 'MFloatMatrix'},
                                                       'right': {'doc': 'this point instance',
                                                                 'type': 'MFloatPoint'}},
                                           'args': [('left',
                                                     'MFloatMatrix',
                                                     'in'),
                                                    ('right',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['left', 'right'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A point representing the product ',
                                                          'qualifiers': ['MFloatPoint'],
                                                          'type': ('MFloatPoint',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MFloatPoint',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'left': ['const',
                                                                       '&'],
                                                              'right': ['const',
                                                                        '&']},
                                           'types': {'left': 'MFloatMatrix',
                                                     'right': 'MFloatPoint'}}],
                              '__ne__': [{'argInfo': {'other': {'doc': 'The point to compare with. ',
                                                                'type': 'MFloatPoint'}},
                                          'args': [('other',
                                                    'MFloatPoint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThe inequality operator. Returns true if any of the x, y, z, and w components of the two points are not identical.',
                                          'inArgs': ['other'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'other': ['const',
                                                                       '&']},
                                          'types': {'other': 'MFloatPoint'}}],
                              '__sub__': [{'argInfo': {'other': {'doc': 'The point to substract.',
                                                                 'type': 'MFloatPoint'}},
                                           'args': [('other',
                                                     'MFloatPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe subtraction operator for two MFloatPoints. The result is the  MFloatVector  from the other point to this instance.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MFloatVector from the other point to this point. ',
                                                          'qualifiers': [],
                                                          'type': 'MFloatVector'},
                                           'returnType': 'MFloatVector',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MFloatPoint'}},
                                          {'argInfo': {'other': {'doc': 'The vector to substract. ',
                                                                 'type': 'MFloatVector'}},
                                           'args': [('other',
                                                     'MFloatVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe operator for subtracting an  MFloatVector  from an  MFloatPoint . A new point is returned whose position is that of the original point translated by the inverse of the vector.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MFloatPoint'},
                                           'returnType': 'MFloatPoint',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MFloatVector'}}],
                              'cartesianize': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nIf this point instance is of the form P(W*x, W*y, W*z, W), for some scale factor W != 0, then it is reset to be P(x, y, z, 1). This will only work correctly if the point is in homogenous form or cartesian form. If the point is in rational form, the results are not defined. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['&'],
                                                               'type': 'MFloatPoint'},
                                                'returnType': 'MFloatPoint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'distanceTo': [{'argInfo': {'other': {'doc': 'the point to compute the distance to',
                                                                    'type': 'MFloatPoint'}},
                                              'args': [('other',
                                                        'MFloatPoint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the distance between this instance and the point passed as an argument.',
                                              'inArgs': ['other'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The distance between the two points. ',
                                                             'qualifiers': [],
                                                             'type': 'float'},
                                              'returnType': 'float',
                                              'static': False,
                                              'typeQualifiers': {'other': ['const',
                                                                           '&']},
                                              'types': {'other': 'MFloatPoint'}}],
                              'get': [{'argInfo': {'dest': {'doc': 'the four element array of doubles',
                                                            'type': 'double__array4'}},
                                       'args': [('dest',
                                                 'double__array4',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the values of x, y, z, and w from the instance to the four elements of the given array of doubles.',
                                       'inArgs': [],
                                       'outArgs': ['dest'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'dest': []},
                                       'types': {'dest': 'double__array4'}},
                                      {'argInfo': {'dest': {'doc': 'the four element array of floats',
                                                            'type': 'float__array4'}},
                                       'args': [('dest',
                                                 'float__array4',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the values of x, y, z, and w from the instance to the four elements of the given array of floats.',
                                       'inArgs': [],
                                       'outArgs': ['dest'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'dest': []},
                                       'types': {'dest': 'float__array4'}}],
                              'homogenize': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nIf this point instance is of the form P(x, y, z, W) (ie. is in rational or (for W==1) cartesian form), for some scale factor W != 0, then it is reset to be P(W*x, W*y, W*z, W). \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['&'],
                                                             'type': 'MFloatPoint'},
                                              'returnType': 'MFloatPoint',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'isEquivalent': [{'argInfo': {'other': {'doc': 'the other point to compare to ',
                                                                      'type': 'MFloatPoint'},
                                                            'tol': {'doc': 'the tolerance to use during the comparison',
                                                                    'type': 'float'}},
                                                'args': [('other',
                                                          'MFloatPoint',
                                                          'in'),
                                                         ('tol',
                                                          'float',
                                                          'in')],
                                                'defaults': {'tol': 1e-05},
                                                'deprecated': False,
                                                'doc': '\r\nReturns true if this instance the the point passed as an argument represent the same position within the specified tolerance.',
                                                'inArgs': ['other',
                                                           'tol'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'True if the points are equal within the given tolerance and false otherwise. ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'other': ['const',
                                                                             '&'],
                                                                   'tol': []},
                                                'types': {'other': 'MFloatPoint',
                                                          'tol': 'float'}}],
                              'rationalize': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nIf this point instance is of the form P(W*x, W*y, W*z, W) (ie. is in homogenous or (for W==1) cartesian form), for some scale factor W != 0, then it is reset to be P(x, y, z, W). This will only work correctly if the point is in homogenous or cartesian form. If the point is already in rational form, the resultsare not defined. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['&'],
                                                              'type': 'MFloatPoint'},
                                               'returnType': 'MFloatPoint',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'setCast': [{'argInfo': {'srcpt': {'doc': 'the point to copy the x, y, z and w values from.',
                                                                 'type': 'MPoint'}},
                                           'args': [('srcpt',
                                                     'MPoint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nCopy the values of x, y, z, and w from srcpt to the instance.',
                                           'inArgs': ['srcpt'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'srcpt': ['const',
                                                                        '&']},
                                           'types': {'srcpt': 'MPoint'}},
                                          {'argInfo': {'src': {'doc': 'the vector to copy the x, y, z and w values from.',
                                                               'type': 'MVector'}},
                                           'args': [('src',
                                                     'MVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nCopy the values of x, y, z, and w from src to the instance.',
                                           'inArgs': ['src'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'src': ['const',
                                                                      '&']},
                                           'types': {'src': 'MVector'}},
                                          {'argInfo': {'d': {'doc': 'the four element array of doubles',
                                                             'type': 'double__array4'}},
                                           'args': [('d',
                                                     'double__array4',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nCopy the values of x, y, z, and w to the instance from the four elements of the given array of doubles.',
                                           'inArgs': ['d'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'d': ['const']},
                                           'types': {'d': 'double__array4'}}]},
                  'pymelEnums': {}},
  'MFloatPointArray': {'enums': {},
                       'invertibles': [('setSizeIncrement',
                                        'sizeIncrement'),
                                       ('setLength', 'length')],
                       'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                    'inArgs': ['index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the indicated element. ',
                                                                   'qualifiers': ['&'],
                                                                   'type': 'MFloatPoint'},
                                                    'returnType': 'MFloatPoint',
                                                    'static': False,
                                                    'typeQualifiers': {'index': ['unsigned']},
                                                    'types': {'index': 'uint'}},
                                                   {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                    'inArgs': ['index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A reference to the indicated element ',
                                                                   'qualifiers': ['&'],
                                                                   'type': 'MFloatPoint'},
                                                    'returnType': 'MFloatPoint',
                                                    'static': False,
                                                    'typeQualifiers': {'index': ['unsigned']},
                                                    'types': {'index': 'uint'}}],
                                   'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                       'type': 'MFloatPoint'}},
                                               'args': [('element',
                                                         'MFloatPoint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                               'inArgs': ['element'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'element': ['const',
                                                                              '&']},
                                               'types': {'element': 'MFloatPoint'}},
                                              {'argInfo': {'w': {'doc': 'the value for the w component, defaulted to 1',
                                                                 'type': 'float'},
                                                           'x': {'doc': 'the value for the x component ',
                                                                 'type': 'float'},
                                                           'y': {'doc': 'the value for the y component ',
                                                                 'type': 'float'},
                                                           'z': {'doc': 'the value for the z component, defaulted to 0 ',
                                                                 'type': 'float'}},
                                               'args': [('x',
                                                         'float',
                                                         'in'),
                                                        ('y',
                                                         'float',
                                                         'in'),
                                                        ('z',
                                                         'float',
                                                         'in'),
                                                        ('w',
                                                         'float',
                                                         'in')],
                                               'defaults': {'w': 1.0,
                                                            'z': 0.0},
                                               'deprecated': False,
                                               'doc': '\r\nAdds a new element to the end of the array. The appended element has the indicated values for its x,y,z and w components. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.',
                                               'inArgs': ['x',
                                                          'y',
                                                          'z',
                                                          'w'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'w': [],
                                                                  'x': [],
                                                                  'y': [],
                                                                  'z': []},
                                               'types': {'w': 'float',
                                                         'x': 'float',
                                                         'y': 'float',
                                                         'z': 'float'}}],
                                   'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'clear': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                   'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                    'type': 'MFloatPointArray'}},
                                             'args': [('source',
                                                       'MFloatPointArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCopy the contents of the source array to this array.',
                                             'inArgs': ['source'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'source': ['const',
                                                                           '&']},
                                             'types': {'source': 'MFloatPointArray'}}],
                                   'get': [{'argInfo': {'dest': {'doc': 'the array to populate',
                                                                 'type': 'float__array'}},
                                            'args': [('dest',
                                                      'float__array',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCopy the elements of the array into the C++ array of float arrays. No checking is done to ensure that the destination C++ array of float arrays is large enough to hold all the elements of the instance.',
                                            'inArgs': [],
                                            'outArgs': ['dest'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'dest': []},
                                            'types': {'dest': 'float__array'}},
                                           {'argInfo': {'dest': {'doc': 'the array to populate',
                                                                 'type': 'double__array'}},
                                            'args': [('dest',
                                                      'double__array',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCopy the elements of the array into the C++ array of double arrays. No checking is done to ensure that the destination C++ array of double arrays is large enough to hold all the elements of the instance.',
                                            'inArgs': [],
                                            'outArgs': ['dest'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'dest': []},
                                            'types': {'dest': 'double__array'}}],
                                   'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                       'type': 'MFloatPoint'},
                                                           'index': {'doc': 'the index of the element to set to the the new value',
                                                                     'type': 'uint'}},
                                               'args': [('element',
                                                         'MFloatPoint',
                                                         'in'),
                                                        ('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                               'inArgs': ['element',
                                                          'index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'element': ['const',
                                                                              '&'],
                                                                  'index': ['unsigned']},
                                               'types': {'element': 'MFloatPoint',
                                                         'index': 'uint'}}],
                                   'length': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the number of elements in the instance.',
                                               'inArgs': [],
                                               'inverse': ('setLength',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The number of elements in the instance ',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                   'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                                   'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                    'type': 'MFloatPoint'},
                                                        'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                  'type': 'uint'}},
                                            'args': [('element',
                                                      'MFloatPoint',
                                                      'in'),
                                                     ('index',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets the value of the indicated element to the indicated value.',
                                            'inArgs': ['element',
                                                       'index'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'element': ['const',
                                                                           '&'],
                                                               'index': ['unsigned']},
                                            'types': {'element': 'MFloatPoint',
                                                      'index': 'uint'}},
                                           {'argInfo': {'index': {'doc': 'the index of the element that is to be set to the the new value ',
                                                                  'type': 'uint'},
                                                        'w': {'doc': 'the new value for the w component,defaulted to 1',
                                                              'type': 'float'},
                                                        'x': {'doc': 'the new value for the x component ',
                                                              'type': 'float'},
                                                        'y': {'doc': 'the new value for the y component ',
                                                              'type': 'float'},
                                                        'z': {'doc': 'the new value for the z component,defaulted to 0 ',
                                                              'type': 'float'}},
                                            'args': [('index',
                                                      'uint',
                                                      'in'),
                                                     ('x',
                                                      'float',
                                                      'in'),
                                                     ('y',
                                                      'float',
                                                      'in'),
                                                     ('z',
                                                      'float',
                                                      'in'),
                                                     ('w',
                                                      'float',
                                                      'in')],
                                            'defaults': {'w': 1.0,
                                                         'z': 0.0},
                                            'deprecated': False,
                                            'doc': '\r\nSets the value of the indicated element to the indicated values. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.',
                                            'inArgs': ['index',
                                                       'x',
                                                       'y',
                                                       'z',
                                                       'w'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'index': ['unsigned'],
                                                               'w': [],
                                                               'x': [],
                                                               'y': [],
                                                               'z': []},
                                            'types': {'index': 'uint',
                                                      'w': 'float',
                                                      'x': 'float',
                                                      'y': 'float',
                                                      'z': 'float'}},
                                           {'argInfo': {'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                  'type': 'uint'},
                                                        'val': {'doc': 'the new value for the indicated element ',
                                                                'type': 'float__array4'}},
                                            'args': [('val',
                                                      'float__array4',
                                                      'in'),
                                                     ('index',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets the value of the indicated element to the indicated value. The x component of the element is set to val[0], the y component to val[1], the z component to val[2], and the w component to val[3].',
                                            'inArgs': ['val', 'index'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'index': ['unsigned'],
                                                               'val': []},
                                            'types': {'index': 'uint',
                                                      'val': 'float__array4'}},
                                           {'argInfo': {'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                  'type': 'uint'},
                                                        'val': {'doc': 'the new value for the indicated element ',
                                                                'type': 'double__array4'}},
                                            'args': [('val',
                                                      'double__array4',
                                                      'in'),
                                                     ('index',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets the value of the indicated element to the indicated value. The x component of the element is set to val[0], the y component to val[1], the z component to val[2], and the w component to val[3].',
                                            'inArgs': ['val', 'index'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'index': ['unsigned'],
                                                               'val': []},
                                            'types': {'index': 'uint',
                                                      'val': 'double__array4'}}],
                                   'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                         'type': 'uint'}},
                                                  'args': [('length',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                                  'inArgs': ['length'],
                                                  'inverse': ('length',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'length': ['unsigned']},
                                                  'types': {'length': 'uint'}}],
                                   'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                      'type': 'uint'}},
                                                         'args': [('newIncrement',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                         'inArgs': ['newIncrement'],
                                                         'inverse': ('sizeIncrement',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'newIncrement': ['unsigned']},
                                                         'types': {'newIncrement': 'uint'}}],
                                   'sizeIncrement': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                      'inArgs': [],
                                                      'inverse': ('setSizeIncrement',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                       'pymelEnums': {},
                       'pymelMethods': {'length': 'getLength',
                                        'sizeIncrement': 'getSizeIncrement'}},
  'MFloatVector': {'enums': {},
                   'methods': {'__add__': [{'argInfo': {'other': {'doc': 'Vector to add.',
                                                                  'type': 'MFloatVector'}},
                                            'args': [('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe vector addition operator.',
                                            'inArgs': ['other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The resulting vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&']},
                                            'types': {'other': 'MFloatVector'}}],
                               '__div__': [{'argInfo': {'scalar': {'doc': 'Division factor.',
                                                                   'type': 'float'}},
                                            'args': [('scalar',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe division operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'scalar': []},
                                            'types': {'scalar': 'float'}}],
                               '__eq__': [{'argInfo': {'other': {'doc': 'Vector to compare against.',
                                                                 'type': 'MFloatVector'}},
                                           'args': [('other',
                                                     'MFloatVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe vector equality operator. This returns true if all three of the x, y, and z components are identical.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Bool true if the vectors are identical and false otherwise. ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MFloatVector'}}],
                               '__getitem__': [{'argInfo': {'i': {'doc': 'Value indicating which component to return.',
                                                                  'type': 'uint'}},
                                                'args': [('i',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThe index operator. If its argument is 0 it will return the x component of the vector. If its argument is 1 it will return the y component of the vector. Otherwise it will return the z component of the vector.',
                                                'inArgs': ['i'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The vector component. ',
                                                               'qualifiers': [],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {'i': ['unsigned']},
                                                'types': {'i': 'uint'}},
                                               {'argInfo': {'i': {'doc': 'Value indicating which component to return.',
                                                                  'type': 'uint'}},
                                                'args': [('i',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                'inArgs': ['i'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Reference to the vector component. ',
                                                               'qualifiers': ['&'],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {'i': ['unsigned']},
                                                'types': {'i': 'uint'}}],
                               '__iadd__': [{'argInfo': {'other': {'doc': 'Vector to add.',
                                                                   'type': 'MFloatVector'}},
                                             'args': [('other',
                                                       'MFloatVector',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place vector addition operator.',
                                             'inArgs': ['other'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the resulting vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'other': ['const',
                                                                          '&']},
                                             'types': {'other': 'MFloatVector'}}],
                               '__idiv__': [{'argInfo': {'scalar': {'doc': 'Division factor.',
                                                                    'type': 'float'}},
                                             'args': [('scalar',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place division operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'scalar': []},
                                             'types': {'scalar': 'float'}}],
                               '__imul__': [{'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'int'}},
                                             'args': [('scalar',
                                                       'int',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'scalar': []},
                                             'types': {'scalar': 'int'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'short'}},
                                             'args': [('scalar',
                                                       'short',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'scalar': []},
                                             'types': {'scalar': 'short'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'uint'}},
                                             'args': [('scalar',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'scalar': ['unsigned']},
                                             'types': {'scalar': 'uint'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'short'}},
                                             'args': [('scalar',
                                                       'short',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'scalar': ['unsigned']},
                                             'types': {'scalar': 'short'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'float'}},
                                             'args': [('scalar',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'scalar': []},
                                             'types': {'scalar': 'float'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'double'}},
                                             'args': [('scalar',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'scalar': []},
                                             'types': {'scalar': 'double'}},
                                            {'argInfo': {'right': {'doc': '',
                                                                   'type': 'MFloatMatrix'}},
                                             'args': [('right',
                                                       'MFloatMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place matrix multiplication operator. \r\n',
                                             'inArgs': ['right'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'right': ['const',
                                                                          '&']},
                                             'types': {'right': 'MFloatMatrix'}}],
                               '__isub__': [{'argInfo': {'other': {'doc': 'Vector to substract.',
                                                                   'type': 'MFloatVector'}},
                                             'args': [('other',
                                                       'MFloatVector',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThe in place vector subtraction operator.',
                                             'inArgs': ['other'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the resulting vector. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {'other': ['const',
                                                                          '&']},
                                             'types': {'other': 'MFloatVector'}}],
                               '__mul__': [{'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'int'}},
                                            'args': [('scalar',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'scalar': []},
                                            'types': {'scalar': 'int'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'short'}},
                                            'args': [('scalar',
                                                      'short',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'scalar': []},
                                            'types': {'scalar': 'short'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'uint'}},
                                            'args': [('scalar',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'scalar': ['unsigned']},
                                            'types': {'scalar': 'uint'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'short'}},
                                            'args': [('scalar',
                                                      'short',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'scalar': ['unsigned']},
                                            'types': {'scalar': 'short'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'float'}},
                                            'args': [('scalar',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'scalar': []},
                                            'types': {'scalar': 'float'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'double'}},
                                            'args': [('scalar',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'scalar': []},
                                            'types': {'scalar': 'double'}},
                                           {'argInfo': {'right': {'doc': '',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe matrix multiplication operator. \r\n',
                                            'inArgs': ['right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'right': ['const',
                                                                         '&']},
                                            'types': {'right': 'MFloatMatrix'}},
                                           {'argInfo': {'right': {'doc': 'Vector take the dot product with.',
                                                                  'type': 'MFloatVector'}},
                                            'args': [('right',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe dot product operator.',
                                            'inArgs': ['right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Dot product value. ',
                                                           'qualifiers': [],
                                                           'type': 'float'},
                                            'returnType': 'float',
                                            'static': False,
                                            'typeQualifiers': {'right': ['const',
                                                                         '&']},
                                            'types': {'right': 'MFloatVector'}},
                                           {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                                  'type': 'MFloatVector'},
                                                        'scalar': {'doc': 'multiplication factor. ',
                                                                   'type': 'int'}},
                                            'args': [('scalar',
                                                      'int',
                                                      'in'),
                                                     ('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['scalar', 'other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled vector. ',
                                                           'qualifiers': ['MFloatVector'],
                                                           'type': ('MFloatVector',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatVector',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'scalar': []},
                                            'types': {'other': 'MFloatVector',
                                                      'scalar': 'int'}},
                                           {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                                  'type': 'MFloatVector'},
                                                        'scalar': {'doc': 'multiplication factor. ',
                                                                   'type': 'short'}},
                                            'args': [('scalar',
                                                      'short',
                                                      'in'),
                                                     ('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['scalar', 'other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled vector. ',
                                                           'qualifiers': ['MFloatVector'],
                                                           'type': ('MFloatVector',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatVector',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'scalar': []},
                                            'types': {'other': 'MFloatVector',
                                                      'scalar': 'short'}},
                                           {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                                  'type': 'MFloatVector'},
                                                        'scalar': {'doc': 'multiplication factor. ',
                                                                   'type': 'uint'}},
                                            'args': [('scalar',
                                                      'uint',
                                                      'in'),
                                                     ('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['scalar', 'other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled vector. ',
                                                           'qualifiers': ['MFloatVector'],
                                                           'type': ('MFloatVector',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatVector',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'scalar': ['unsigned']},
                                            'types': {'other': 'MFloatVector',
                                                      'scalar': 'uint'}},
                                           {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                                  'type': 'MFloatVector'},
                                                        'scalar': {'doc': 'multiplication factor. ',
                                                                   'type': 'short'}},
                                            'args': [('scalar',
                                                      'short',
                                                      'in'),
                                                     ('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['scalar', 'other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled vector. ',
                                                           'qualifiers': ['MFloatVector'],
                                                           'type': ('MFloatVector',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatVector',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'scalar': ['unsigned']},
                                            'types': {'other': 'MFloatVector',
                                                      'scalar': 'short'}},
                                           {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                                  'type': 'MFloatVector'},
                                                        'scalar': {'doc': 'multiplication factor. ',
                                                                   'type': 'float'}},
                                            'args': [('scalar',
                                                      'float',
                                                      'in'),
                                                     ('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['scalar', 'other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled vector. ',
                                                           'qualifiers': ['MFloatVector'],
                                                           'type': ('MFloatVector',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatVector',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'scalar': []},
                                            'types': {'other': 'MFloatVector',
                                                      'scalar': 'float'}},
                                           {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                                  'type': 'MFloatVector'},
                                                        'scalar': {'doc': 'multiplication factor. ',
                                                                   'type': 'double'}},
                                            'args': [('scalar',
                                                      'double',
                                                      'in'),
                                                     ('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['scalar', 'other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled vector. ',
                                                           'qualifiers': ['MFloatVector'],
                                                           'type': ('MFloatVector',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatVector',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'scalar': []},
                                            'types': {'other': 'MFloatVector',
                                                      'scalar': 'double'}},
                                           {'argInfo': {'left': {'doc': 'the matrix on the left ',
                                                                 'type': 'MFloatMatrix'},
                                                        'right': {'doc': 'the matrix on the right',
                                                                  'type': 'MFloatVector'}},
                                            'args': [('left',
                                                      'MFloatMatrix',
                                                      'in'),
                                                     ('right',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['left', 'right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The MFloatVector resulting from the multiplication ',
                                                           'qualifiers': ['MFloatVector'],
                                                           'type': ('MFloatVector',
                                                                    'OPENMAYA_EXPORT')},
                                            'returnType': ('MFloatVector',
                                                           'OPENMAYA_EXPORT'),
                                            'static': False,
                                            'typeQualifiers': {'left': ['const',
                                                                        '&'],
                                                               'right': ['const',
                                                                         '&']},
                                            'types': {'left': 'MFloatMatrix',
                                                      'right': 'MFloatVector'}}],
                               '__ne__': [{'argInfo': {'other': {'doc': 'Vector to compare against.',
                                                                 'type': 'MFloatVector'}},
                                           'args': [('other',
                                                     'MFloatVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe vector inequality operator. This returns false if all three of the x, y, and z components are identical.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Bool false if the vectors are identical and true otherwise. ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MFloatVector'}}],
                               '__sub__': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe unary minus operator. Negates the value of each of the x, y, and z components of the vector.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}},
                                           {'argInfo': {'other': {'doc': 'Vector to substract.',
                                                                  'type': 'MFloatVector'}},
                                            'args': [('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe vector subtraction operator.',
                                            'inArgs': ['other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The resulting vector. ',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&']},
                                            'types': {'other': 'MFloatVector'}}],
                               'angle': [{'argInfo': {'other': {'doc': 'the vector from which to compute the angle.',
                                                                'type': 'MFloatVector'}},
                                          'args': [('other',
                                                    'MFloatVector',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the angle in radians between the vector and the one passed as an argument.',
                                          'inArgs': ['other'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The angle in radians ',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': False,
                                          'typeQualifiers': {'other': ['const',
                                                                       '&']},
                                          'types': {'other': 'MFloatVector'}}],
                               'get': [{'argInfo': {'d': {'doc': 'The array of 3 floats into which the results are placed.',
                                                          'type': 'float__array3'}},
                                        'args': [('d',
                                                  'float__array3',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nExtracts the x, y, and z components of the vector and places them in elements 0, 1, and 2 of the float array passed.',
                                        'inArgs': [],
                                        'outArgs': ['d'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'d': []},
                                        'types': {'d': 'float__array3'}}],
                               'isEquivalent': [{'argInfo': {'other': {'doc': 'the vector to compare to ',
                                                                       'type': 'MFloatVector'},
                                                             'tol': {'doc': 'the tolerance to use during the comparison',
                                                                     'type': 'float'}},
                                                 'args': [('other',
                                                           'MFloatVector',
                                                           'in'),
                                                          ('tol',
                                                           'float',
                                                           'in')],
                                                 'defaults': {'tol': 1e-05},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if the vector and the one passed as an argument are equal to each other within the specified tolerance.',
                                                 'inArgs': ['other',
                                                            'tol'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'true if the vectors are equivalent and false otherwise ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'other': ['const',
                                                                              '&'],
                                                                    'tol': []},
                                                 'types': {'other': 'MFloatVector',
                                                           'tol': 'float'}}],
                               'isParallel': [{'argInfo': {'other': {'doc': 'the vector to compare to ',
                                                                     'type': 'MFloatVector'},
                                                           'tol': {'doc': 'the tolerance to use during the comparison',
                                                                   'type': 'float'}},
                                               'args': [('other',
                                                         'MFloatVector',
                                                         'in'),
                                                        ('tol',
                                                         'float',
                                                         'in')],
                                               'defaults': {'tol': 1e-05},
                                               'deprecated': False,
                                               'doc': '\r\nReturns true if the current vector and the one passed as an argument are parallel to each other within the specified tolerance.',
                                               'inArgs': ['other', 'tol'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if the vectors are parallel and false otherwise ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'other': ['const',
                                                                            '&'],
                                                                  'tol': []},
                                               'types': {'other': 'MFloatVector',
                                                         'tol': 'float'}}],
                               'length': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\n Returns: The length of the vector.  \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'normal': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nComputes a unit vector aligned to the vector.  Returns: The unit vector.  \n  Reprocessed example  \n Examples: \n \n   \n sampleParticles.cpp . \n \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The unit vector. ',
                                                          'qualifiers': [],
                                                          'type': 'MFloatVector'},
                                           'returnType': 'MFloatVector',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'normalize': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nPerforms an in place normalization of the vector',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'transformAsNormal': [{'argInfo': {'matrix': {'doc': 'the transformation matrix',
                                                                             'type': 'MFloatMatrix'}},
                                                      'args': [('matrix',
                                                                'MFloatMatrix',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                      'inArgs': ['matrix'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The resulting transformed vector ',
                                                                     'qualifiers': [],
                                                                     'type': 'MFloatVector'},
                                                      'returnType': 'MFloatVector',
                                                      'static': False,
                                                      'typeQualifiers': {'matrix': ['const',
                                                                                    '&']},
                                                      'types': {'matrix': 'MFloatMatrix'}}]},
                   'pymelEnums': {}},
  'MFloatVectorArray': {'enums': {},
                        'invertibles': [('setSizeIncrement',
                                         'sizeIncrement'),
                                        ('setLength', 'length')],
                        'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the indicated element. ',
                                                                    'qualifiers': ['&'],
                                                                    'type': 'MFloatVector'},
                                                     'returnType': 'MFloatVector',
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A reference to the indicated element ',
                                                                    'qualifiers': ['&'],
                                                                    'type': 'MFloatVector'},
                                                     'returnType': 'MFloatVector',
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}}],
                                    'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                        'type': 'MFloatVector'}},
                                                'args': [('element',
                                                          'MFloatVector',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                                'inArgs': ['element'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'element': ['const',
                                                                               '&']},
                                                'types': {'element': 'MFloatVector'}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'clear': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                     'type': 'MFloatVectorArray'}},
                                              'args': [('source',
                                                        'MFloatVectorArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nCopy the contents of the source array to this array.',
                                              'inArgs': ['source'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'source': ['const',
                                                                            '&']},
                                              'types': {'source': 'MFloatVectorArray'}}],
                                    'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                                   'type': 'double__array'}},
                                             'args': [('array',
                                                       'double__array',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCopy the elements of the array into the given C++ array of double arrays. No checking is done to ensure that the destination C++ array of double arrays is large enough to hold all the elements of the instance.',
                                             'inArgs': [],
                                             'outArgs': ['array'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'array': []},
                                             'types': {'array': 'double__array'}},
                                            {'argInfo': {'array': {'doc': 'the array to populate',
                                                                   'type': 'float__array'}},
                                             'args': [('array',
                                                       'float__array',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCopy the elements of the array into the given C++ array of float arrays. No checking is done to ensure that the destination C++ array of floats arrays is large enough to hold all the elements of the instance.',
                                             'inArgs': [],
                                             'outArgs': ['array'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'array': []},
                                             'types': {'array': 'float__array'}}],
                                    'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                        'type': 'MFloatVector'},
                                                            'index': {'doc': 'the index of the element to set to the the new value',
                                                                      'type': 'uint'}},
                                                'args': [('element',
                                                          'MFloatVector',
                                                          'in'),
                                                         ('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                                'inArgs': ['element',
                                                           'index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'element': ['const',
                                                                               '&'],
                                                                   'index': ['unsigned']},
                                                'types': {'element': 'MFloatVector',
                                                          'index': 'uint'}}],
                                    'length': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the number of elements in the instance.',
                                                'inArgs': [],
                                                'inverse': ('setLength',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of elements in the instance ',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                    'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                                    'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                     'type': 'MFloatVector'},
                                                         'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                   'type': 'uint'}},
                                             'args': [('element',
                                                       'MFloatVector',
                                                       'in'),
                                                      ('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the value of the indicated element to the indicated  MFloatVector  value.',
                                             'inArgs': ['element',
                                                        'index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'element': ['const',
                                                                            '&'],
                                                                'index': ['unsigned']},
                                             'types': {'element': 'MFloatVector',
                                                       'index': 'uint'}},
                                            {'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                     'type': 'double__array3'},
                                                         'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                   'type': 'uint'}},
                                             'args': [('element',
                                                       'double__array3',
                                                       'in'),
                                                      ('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the value of the indicated element to the indicated double array value.',
                                             'inArgs': ['element',
                                                        'index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'element': [],
                                                                'index': ['unsigned']},
                                             'types': {'element': 'double__array3',
                                                       'index': 'uint'}},
                                            {'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                     'type': 'float__array3'},
                                                         'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                   'type': 'uint'}},
                                             'args': [('element',
                                                       'float__array3',
                                                       'in'),
                                                      ('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the value of the indicated element to the indicated float array value.',
                                             'inArgs': ['element',
                                                        'index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'element': [],
                                                                'index': ['unsigned']},
                                             'types': {'element': 'float__array3',
                                                       'index': 'uint'}}],
                                    'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                          'type': 'uint'}},
                                                   'args': [('length',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                                   'inArgs': ['length'],
                                                   'inverse': ('length',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'length': ['unsigned']},
                                                   'types': {'length': 'uint'}}],
                                    'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                       'type': 'uint'}},
                                                          'args': [('newIncrement',
                                                                    'uint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                          'inArgs': ['newIncrement'],
                                                          'inverse': ('sizeIncrement',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'newIncrement': ['unsigned']},
                                                          'types': {'newIncrement': 'uint'}}],
                                    'sizeIncrement': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                       'inArgs': [],
                                                       'inverse': ('setSizeIncrement',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}]},
                        'pymelEnums': {},
                        'pymelMethods': {'length': 'getLength',
                                         'sizeIncrement': 'getSizeIncrement'}},
  'MFn': {'enums': {'Type': {'valueDocs': {'AISEnvFacade': '',
                                           'DOF': '',
                                           'DPbirailSrf': '',
                                           'FFD': '',
                                           'FFblendSrf': '',
                                           'FFfilletSrf': '',
                                           'MCsolver': '',
                                           'MPbirailSrf': '',
                                           'NBase': '',
                                           'NCloth': '',
                                           'NComponent': '',
                                           'NId': '',
                                           'NIdData': '',
                                           'NLE': 'NLE node.',
                                           'NObject': '',
                                           'NObjectData': '',
                                           'NParticle': '',
                                           'NRigid': '',
                                           'PASolver': '',
                                           'RBFsurface': '',
                                           'RPsolver': '',
                                           'SCsolver': '',
                                           'SPbirailSrf': '',
                                           'UInt64ArrayData': '',
                                           'UVManip2D': '',
                                           'addDoubleLinear': '',
                                           'adskMaterial': 'Consistent material asset from an Autodesk Material Library.',
                                           'affect': '',
                                           'aimConstraint': '',
                                           'air': '',
                                           'alignCurve': '',
                                           'alignManip': '',
                                           'alignSurface': '',
                                           'ambientLight': '',
                                           'angle': '',
                                           'angleBetween': '',
                                           'animBlend': '',
                                           'animBlendInOut': '',
                                           'animCurve': '',
                                           'animCurveTimeToAngular': '',
                                           'animCurveTimeToDistance': '',
                                           'animCurveTimeToTime': '',
                                           'animCurveTimeToUnitless': '',
                                           'animCurveUnitlessToAngular': '',
                                           'animCurveUnitlessToDistance': '',
                                           'animCurveUnitlessToTime': '',
                                           'animCurveUnitlessToUnitless': '',
                                           'animLayer': '',
                                           'anisotropy': '',
                                           'annotation': '',
                                           'anyGeometryVarGroup': '',
                                           'arcLength': '',
                                           'areaLight': '',
                                           'arrayMapper': '',
                                           'arrowManip': '',
                                           'assembly': 'Base class for scene assembly nodes.',
                                           'asset': '',
                                           'attachCurve': '',
                                           'attachSurface': '',
                                           'attribute': '',
                                           'attribute2Double': '',
                                           'attribute2Float': '',
                                           'attribute2Int': '',
                                           'attribute2Long': 'Used for backward compatibility.',
                                           'attribute2Short': '',
                                           'attribute3Double': '',
                                           'attribute3Float': '',
                                           'attribute3Int': '',
                                           'attribute3Long': 'Used for backward compatibility.',
                                           'attribute3Short': '',
                                           'attribute4Double': '',
                                           'audio': '',
                                           'averageCurveManip': '',
                                           'avgCurves': '',
                                           'avgNurbsSurfacePoints': '',
                                           'avgSurfacePoints': '',
                                           'axesActionManip': '',
                                           'background': '',
                                           'ballProjectionManip': '',
                                           'barnDoorManip': '',
                                           'base': '',
                                           'baseLattice': '',
                                           'bendLattice': '',
                                           'bevel': '',
                                           'bevelManip': '',
                                           'bevelPlus': '',
                                           'bezierCurve': '',
                                           'bezierCurveData': '',
                                           'bezierCurveToNurbs': '',
                                           'binaryData': '',
                                           'birailSrf': '',
                                           'blend': '',
                                           'blendColorSet': '',
                                           'blendColors': '',
                                           'blendDevice': '',
                                           'blendManip': '',
                                           'blendNodeAdditiveRotation': '',
                                           'blendNodeAdditiveScale': '',
                                           'blendNodeBase': '',
                                           'blendNodeBoolean': '',
                                           'blendNodeDouble': '',
                                           'blendNodeDoubleAngle': '',
                                           'blendNodeDoubleLinear': '',
                                           'blendNodeEnum': '',
                                           'blendNodeFloat': '',
                                           'blendNodeFloatAngle': '',
                                           'blendNodeFloatLinear': '',
                                           'blendNodeInt16': '',
                                           'blendNodeInt32': '',
                                           'blendNodeTime': '',
                                           'blendShape': '',
                                           'blendTwoAttr': '',
                                           'blendWeighted': '',
                                           'blindData': '',
                                           'blindDataTemplate': '',
                                           'blinn': '',
                                           'blinnMaterial': '',
                                           'boundary': '',
                                           'box': '',
                                           'boxData': '',
                                           'brownian': '',
                                           'brush': '',
                                           'bulge': '',
                                           'bulgeLattice': '',
                                           'bump': '',
                                           'bump3d': '',
                                           'buttonManip': '',
                                           'cacheBase': '',
                                           'cacheBlend': '',
                                           'cacheFile': '',
                                           'cacheTrack': '',
                                           'cacheableNode': '',
                                           'caddyManipBase': '',
                                           'camera': '',
                                           'cameraManip': '',
                                           'cameraPlaneManip': '',
                                           'cameraSet': '',
                                           'cameraView': '',
                                           'centerManip': '',
                                           'chainToSpline': '',
                                           'character': '',
                                           'characterMap': '',
                                           'characterMappingData': '',
                                           'characterOffset': '',
                                           'checker': '',
                                           'choice': '',
                                           'chooser': '',
                                           'circle': '',
                                           'circleManip': '',
                                           'circlePointManip': '',
                                           'circleSweepManip': '',
                                           'clampColor': '',
                                           'clientDevice': '',
                                           'clip': '',
                                           'clipGhostShape': '',
                                           'clipLibrary': '',
                                           'clipScheduler': '',
                                           'clipToGhostData': '',
                                           'closeCurve': '',
                                           'closeSurface': '',
                                           'closestPointOnMesh': '',
                                           'closestPointOnSurface': '',
                                           'cloth': '',
                                           'cloud': '',
                                           'cluster': '',
                                           'clusterFilter': '',
                                           'clusterFlexor': '',
                                           'coiManip': '',
                                           'collision': '',
                                           'colorBackground': '',
                                           'colorMgtGlobals': 'Color management globals node.',
                                           'colorProfile': 'Color Profile Node.',
                                           'combinationShape': '',
                                           'commCornerManip': '',
                                           'commCornerOperManip': '',
                                           'commEdgeOperManip': '',
                                           'commEdgePtManip': '',
                                           'commEdgeSegmentManip': '',
                                           'component': '',
                                           'componentListData': '',
                                           'componentManip': '',
                                           'compoundAttribute': '',
                                           'concentricProjectionManip': '',
                                           'condition': '',
                                           'cone': '',
                                           'constraint': '',
                                           'container': '',
                                           'containerBase': 'base class for containers',
                                           'contourProjectionManip': '',
                                           'contrast': '',
                                           'control': '',
                                           'controllerTag': '',
                                           'copyColorSet': '',
                                           'copyUVSet': '',
                                           'cpManip': '',
                                           'crater': '',
                                           'creaseSet': 'Crease Set Node.',
                                           'create': '',
                                           'createBPManip': '',
                                           'createBezierManip': '',
                                           'createCVManip': '',
                                           'createColorSet': '',
                                           'createEPManip': '',
                                           'createSectionManip': '',
                                           'createUVSet': '',
                                           'crossSectionEditManip': '',
                                           'crossSectionManager': '',
                                           'cubicProjectionManip': '',
                                           'curve': '',
                                           'curveCVComponent': '',
                                           'curveCurveIntersect': '',
                                           'curveEPComponent': '',
                                           'curveEdManip': '',
                                           'curveFromMeshCoM': '',
                                           'curveFromMeshEdge': '',
                                           'curveFromSubdivEdge': '',
                                           'curveFromSubdivFace': '',
                                           'curveFromSurface': '',
                                           'curveFromSurfaceBnd': '',
                                           'curveFromSurfaceCoS': '',
                                           'curveFromSurfaceIso': '',
                                           'curveInfo': '',
                                           'curveKnotComponent': '',
                                           'curveNormalizerAngle': '',
                                           'curveNormalizerLinear': '',
                                           'curveParamComponent': '',
                                           'curveSegmentManip': '',
                                           'curveVarGroup': '',
                                           'customEvaluatorClusterNode': '',
                                           'cylinder': '',
                                           'cylindricalProjectionManip': '',
                                           'dagContainer': 'dag container node',
                                           'dagNode': '',
                                           'dagPose': '',
                                           'dagSelectionItem': '',
                                           'data': '',
                                           'data2Double': '',
                                           'data2Float': '',
                                           'data2Int': '',
                                           'data2Long': 'Used for backward compatibility.',
                                           'data2Short': '',
                                           'data3Double': '',
                                           'data3Float': '',
                                           'data3Int': '',
                                           'data3Long': 'Used for backward compatibility.',
                                           'data3Short': '',
                                           'data4Double': '',
                                           'dblTrsManip': '',
                                           'decayRegionCapComponent': '',
                                           'decayRegionComponent': '',
                                           'defaultLightList': '',
                                           'deformBend': '',
                                           'deformBendManip': '',
                                           'deformFlare': '',
                                           'deformFlareManip': '',
                                           'deformFunc': '',
                                           'deformSine': '',
                                           'deformSineManip': '',
                                           'deformSquash': '',
                                           'deformSquashManip': '',
                                           'deformTwist': '',
                                           'deformTwistManip': '',
                                           'deformWave': '',
                                           'deformWaveManip': '',
                                           'deleteColorSet': '',
                                           'deleteComponent': '',
                                           'deleteUVSet': '',
                                           'deltaMush': '',
                                           'dependencyNode': '',
                                           'detachCurve': '',
                                           'detachSurface': '',
                                           'diffuseMaterial': '',
                                           'dimension': '',
                                           'dimensionManip': '',
                                           'directedDisc': '',
                                           'directionManip': '',
                                           'directionalLight': '',
                                           'discManip': '',
                                           'diskCache': '',
                                           'dispatchCompute': '',
                                           'displacementShader': '',
                                           'displayLayer': '',
                                           'displayLayerManager': '',
                                           'distance': '',
                                           'distanceBetween': '',
                                           'distanceManip': '',
                                           'dofManip': '',
                                           'doubleAngleAttribute': '',
                                           'doubleArrayData': '',
                                           'doubleIndexedComponent': '',
                                           'doubleLinearAttribute': '',
                                           'doubleShadingSwitch': '',
                                           'drag': '',
                                           'dropOffFunction': '',
                                           'dropoffLocator': '',
                                           'dropoffManip': '',
                                           'dummy': '',
                                           'dummyConnectable': '',
                                           'dynAirManip': '',
                                           'dynArrayAttrsData': '',
                                           'dynAttenuationManip': '',
                                           'dynBase': '',
                                           'dynBaseFieldManip': '',
                                           'dynEmitterManip': '',
                                           'dynFieldsManip': '',
                                           'dynGlobals': '',
                                           'dynNewtonManip': '',
                                           'dynParticleSetComponent': '',
                                           'dynSpreadManip': '',
                                           'dynSweptGeometryData': '',
                                           'dynTurbulenceManip': '',
                                           'dynamicConstraint': '',
                                           'dynamicsController': '',
                                           'edgeComponent': '',
                                           'editCurve': '',
                                           'editCurveManip': '',
                                           'editMetadata': 'editMetadata Node',
                                           'editsManager': '',
                                           'emitter': '',
                                           'enableManip': '',
                                           'enumAttribute': '',
                                           'envBall': '',
                                           'envChrome': '',
                                           'envCube': '',
                                           'envFacade': '',
                                           'envFogMaterial': '',
                                           'envFogShape': '',
                                           'envSky': '',
                                           'envSphere': '',
                                           'explodeNurbsShell': '',
                                           'expression': '',
                                           'extendCurve': '',
                                           'extendCurveDistanceManip': '',
                                           'extendSurface': '',
                                           'extendSurfaceDistanceManip': '',
                                           'extract': '',
                                           'extrude': '',
                                           'extrudeManip': '',
                                           'facade': '',
                                           'ffdDualBase': '',
                                           'field': '',
                                           'fileBackground': '',
                                           'fileTexture': '',
                                           'filletCurve': '',
                                           'filter': '',
                                           'filterClosestSample': '',
                                           'filterEuler': '',
                                           'filterSimplify': '',
                                           'fitBspline': '',
                                           'fixedLineManip': '',
                                           'flexor': '',
                                           'floatAngleAttribute': '',
                                           'floatArrayData': '',
                                           'floatLinearAttribute': '',
                                           'floatMatrixAttribute': '',
                                           'floatVectorArrayData': '',
                                           'flow': '',
                                           'fluid': '',
                                           'fluidData': '',
                                           'fluidEmitter': '',
                                           'fluidGeom': '',
                                           'fluidTexture2D': '',
                                           'fluidTexture3D': '',
                                           'follicle': '',
                                           'forceUpdateManip': '',
                                           'fosterParent': '',
                                           'fourByFourMatrix': '',
                                           'fractal': '',
                                           'freePointManip': '',
                                           'freePointTriadManip': '',
                                           'gammaCorrect': '',
                                           'genericAttribute': '',
                                           'geoConnectable': '',
                                           'geoConnector': '',
                                           'geomBind': '',
                                           'geometric': '',
                                           'geometryConstraint': '',
                                           'geometryData': '',
                                           'geometryFilt': '',
                                           'geometryOnLineManip': '',
                                           'geometryVarGroup': '',
                                           'globalCacheControls': '',
                                           'globalStitch': '',
                                           'granite': '',
                                           'gravity': '',
                                           'greasePencilSequence': '',
                                           'greasePlane': '',
                                           'greasePlaneRenderShape': '',
                                           'grid': '',
                                           'groundPlane': '',
                                           'groupId': '',
                                           'groupParts': '',
                                           'guide': '',
                                           'guideLine': '',
                                           'hairConstraint': '',
                                           'hairSystem': '',
                                           'hairTubeShader': '',
                                           'handleRotateManip': '',
                                           'hardenPointCurve': '',
                                           'hardwareReflectionMap': '',
                                           'hardwareRenderGlobals': '',
                                           'hardwareRenderingGlobals': '',
                                           'heightField': '',
                                           'hikEffector': '',
                                           'hikFKJoint': '',
                                           'hikFloorContactMarker': '',
                                           'hikGroundPlane': '',
                                           'hikHandle': '',
                                           'hikIKEffector': '',
                                           'hikSolver': '',
                                           'historySwitch': '',
                                           'hsvToRgb': '',
                                           'hwShaderNode': '',
                                           'hyperGraphInfo': '',
                                           'hyperLayout': '',
                                           'hyperLayoutDG': '',
                                           'hyperView': '',
                                           'ikEffector': '',
                                           'ikHandle': '',
                                           'ikRPManip': '',
                                           'ikSolver': '',
                                           'ikSplineManip': '',
                                           'ikSystem': '',
                                           'illustratorCurve': '',
                                           'imageAdd': '',
                                           'imageBlur': '',
                                           'imageColorCorrect': '',
                                           'imageData': '',
                                           'imageDepth': '',
                                           'imageDiff': '',
                                           'imageDisplay': '',
                                           'imageFilter': '',
                                           'imageLoad': '',
                                           'imageMotionBlur': '',
                                           'imageMultiply': '',
                                           'imageNetDest': '',
                                           'imageNetSrc': '',
                                           'imageOver': '',
                                           'imagePlane': '',
                                           'imageRender': '',
                                           'imageSave': '',
                                           'imageSource': '',
                                           'imageUnder': '',
                                           'imageView': '',
                                           'implicitCone': '',
                                           'implicitSphere': '',
                                           'insertKnotCrv': '',
                                           'insertKnotSrf': '',
                                           'instancer': '',
                                           'int64ArrayData': '',
                                           'intArrayData': '',
                                           'intersectSurface': '',
                                           'invalid': '',
                                           'isoparmComponent': '',
                                           'isoparmManip': '',
                                           'itemList': '',
                                           'jiggleDeformer': '',
                                           'joint': '',
                                           'jointCluster': '',
                                           'jointClusterManip': '',
                                           'jointTranslateManip': '',
                                           'kAISEnvFacade': '',
                                           'kAddDoubleLinear': '',
                                           'kAdskMaterial': 'Consistent material asset from an Autodesk Material Library.',
                                           'kAffect': '',
                                           'kAimConstraint': '',
                                           'kAir': '',
                                           'kAlignCurve': '',
                                           'kAlignManip': '',
                                           'kAlignSurface': '',
                                           'kAmbientLight': '',
                                           'kAngle': '',
                                           'kAngleBetween': '',
                                           'kAnimBlend': '',
                                           'kAnimBlendInOut': '',
                                           'kAnimCurve': '',
                                           'kAnimCurveTimeToAngular': '',
                                           'kAnimCurveTimeToDistance': '',
                                           'kAnimCurveTimeToTime': '',
                                           'kAnimCurveTimeToUnitless': '',
                                           'kAnimCurveUnitlessToAngular': '',
                                           'kAnimCurveUnitlessToDistance': '',
                                           'kAnimCurveUnitlessToTime': '',
                                           'kAnimCurveUnitlessToUnitless': '',
                                           'kAnimLayer': '',
                                           'kAnisotropy': '',
                                           'kAnnotation': '',
                                           'kAnyGeometryVarGroup': '',
                                           'kArcLength': '',
                                           'kAreaLight': '',
                                           'kArrayMapper': '',
                                           'kArrowManip': '',
                                           'kAssembly': 'Base class for scene assembly nodes.',
                                           'kAsset': '',
                                           'kAttachCurve': '',
                                           'kAttachSurface': '',
                                           'kAttribute': '',
                                           'kAttribute2Double': '',
                                           'kAttribute2Float': '',
                                           'kAttribute2Int': '',
                                           'kAttribute2Long': 'Used for backward compatibility.',
                                           'kAttribute2Short': '',
                                           'kAttribute3Double': '',
                                           'kAttribute3Float': '',
                                           'kAttribute3Int': '',
                                           'kAttribute3Long': 'Used for backward compatibility.',
                                           'kAttribute3Short': '',
                                           'kAttribute4Double': '',
                                           'kAudio': '',
                                           'kAverageCurveManip': '',
                                           'kAvgCurves': '',
                                           'kAvgNurbsSurfacePoints': '',
                                           'kAvgSurfacePoints': '',
                                           'kAxesActionManip': '',
                                           'kBackground': '',
                                           'kBallProjectionManip': '',
                                           'kBarnDoorManip': '',
                                           'kBase': '',
                                           'kBaseLattice': '',
                                           'kBendLattice': '',
                                           'kBevel': '',
                                           'kBevelManip': '',
                                           'kBevelPlus': '',
                                           'kBezierCurve': '',
                                           'kBezierCurveData': '',
                                           'kBezierCurveToNurbs': '',
                                           'kBinaryData': '',
                                           'kBirailSrf': '',
                                           'kBlend': '',
                                           'kBlendColorSet': '',
                                           'kBlendColors': '',
                                           'kBlendDevice': '',
                                           'kBlendManip': '',
                                           'kBlendNodeAdditiveRotation': '',
                                           'kBlendNodeAdditiveScale': '',
                                           'kBlendNodeBase': '',
                                           'kBlendNodeBoolean': '',
                                           'kBlendNodeDouble': '',
                                           'kBlendNodeDoubleAngle': '',
                                           'kBlendNodeDoubleLinear': '',
                                           'kBlendNodeEnum': '',
                                           'kBlendNodeFloat': '',
                                           'kBlendNodeFloatAngle': '',
                                           'kBlendNodeFloatLinear': '',
                                           'kBlendNodeInt16': '',
                                           'kBlendNodeInt32': '',
                                           'kBlendNodeTime': '',
                                           'kBlendShape': '',
                                           'kBlendTwoAttr': '',
                                           'kBlendWeighted': '',
                                           'kBlindData': '',
                                           'kBlindDataTemplate': '',
                                           'kBlinn': '',
                                           'kBlinnMaterial': '',
                                           'kBoundary': '',
                                           'kBox': '',
                                           'kBoxData': '',
                                           'kBrownian': '',
                                           'kBrush': '',
                                           'kBulge': '',
                                           'kBulgeLattice': '',
                                           'kBump': '',
                                           'kBump3d': '',
                                           'kButtonManip': '',
                                           'kCacheBase': '',
                                           'kCacheBlend': '',
                                           'kCacheFile': '',
                                           'kCacheTrack': '',
                                           'kCacheableNode': '',
                                           'kCaddyManipBase': '',
                                           'kCamera': '',
                                           'kCameraManip': '',
                                           'kCameraPlaneManip': '',
                                           'kCameraSet': '',
                                           'kCameraView': '',
                                           'kCenterManip': '',
                                           'kChainToSpline': '',
                                           'kCharacter': '',
                                           'kCharacterMap': '',
                                           'kCharacterMappingData': '',
                                           'kCharacterOffset': '',
                                           'kChecker': '',
                                           'kChoice': '',
                                           'kChooser': '',
                                           'kCircle': '',
                                           'kCircleManip': '',
                                           'kCirclePointManip': '',
                                           'kCircleSweepManip': '',
                                           'kClampColor': '',
                                           'kClientDevice': '',
                                           'kClip': '',
                                           'kClipGhostShape': '',
                                           'kClipLibrary': '',
                                           'kClipScheduler': '',
                                           'kClipToGhostData': '',
                                           'kCloseCurve': '',
                                           'kCloseSurface': '',
                                           'kClosestPointOnMesh': '',
                                           'kClosestPointOnSurface': '',
                                           'kCloth': '',
                                           'kCloud': '',
                                           'kCluster': '',
                                           'kClusterFilter': '',
                                           'kClusterFlexor': '',
                                           'kCoiManip': '',
                                           'kCollision': '',
                                           'kColorBackground': '',
                                           'kColorMgtGlobals': 'Color management globals node.',
                                           'kColorProfile': 'Color Profile Node.',
                                           'kCombinationShape': '',
                                           'kCommCornerManip': '',
                                           'kCommCornerOperManip': '',
                                           'kCommEdgeOperManip': '',
                                           'kCommEdgePtManip': '',
                                           'kCommEdgeSegmentManip': '',
                                           'kComponent': '',
                                           'kComponentListData': '',
                                           'kComponentManip': '',
                                           'kCompoundAttribute': '',
                                           'kConcentricProjectionManip': '',
                                           'kCondition': '',
                                           'kCone': '',
                                           'kConstraint': '',
                                           'kContainer': '',
                                           'kContainerBase': 'base class for containers',
                                           'kContourProjectionManip': '',
                                           'kContrast': '',
                                           'kControl': '',
                                           'kControllerTag': '',
                                           'kCopyColorSet': '',
                                           'kCopyUVSet': '',
                                           'kCpManip': '',
                                           'kCrater': '',
                                           'kCreaseSet': 'Crease Set Node.',
                                           'kCreate': '',
                                           'kCreateBPManip': '',
                                           'kCreateBezierManip': '',
                                           'kCreateCVManip': '',
                                           'kCreateColorSet': '',
                                           'kCreateEPManip': '',
                                           'kCreateSectionManip': '',
                                           'kCreateUVSet': '',
                                           'kCrossSectionEditManip': '',
                                           'kCrossSectionManager': '',
                                           'kCubicProjectionManip': '',
                                           'kCurve': '',
                                           'kCurveCVComponent': '',
                                           'kCurveCurveIntersect': '',
                                           'kCurveEPComponent': '',
                                           'kCurveEdManip': '',
                                           'kCurveFromMeshCoM': '',
                                           'kCurveFromMeshEdge': '',
                                           'kCurveFromSubdivEdge': '',
                                           'kCurveFromSubdivFace': '',
                                           'kCurveFromSurface': '',
                                           'kCurveFromSurfaceBnd': '',
                                           'kCurveFromSurfaceCoS': '',
                                           'kCurveFromSurfaceIso': '',
                                           'kCurveInfo': '',
                                           'kCurveKnotComponent': '',
                                           'kCurveNormalizerAngle': '',
                                           'kCurveNormalizerLinear': '',
                                           'kCurveParamComponent': '',
                                           'kCurveSegmentManip': '',
                                           'kCurveVarGroup': '',
                                           'kCustomEvaluatorClusterNode': '',
                                           'kCylinder': '',
                                           'kCylindricalProjectionManip': '',
                                           'kDOF': '',
                                           'kDPbirailSrf': '',
                                           'kDagContainer': 'dag container node',
                                           'kDagNode': '',
                                           'kDagPose': '',
                                           'kDagSelectionItem': '',
                                           'kData': '',
                                           'kData2Double': '',
                                           'kData2Float': '',
                                           'kData2Int': '',
                                           'kData2Long': 'Used for backward compatibility.',
                                           'kData2Short': '',
                                           'kData3Double': '',
                                           'kData3Float': '',
                                           'kData3Int': '',
                                           'kData3Long': 'Used for backward compatibility.',
                                           'kData3Short': '',
                                           'kData4Double': '',
                                           'kDblTrsManip': '',
                                           'kDecayRegionCapComponent': '',
                                           'kDecayRegionComponent': '',
                                           'kDefaultLightList': '',
                                           'kDeformBend': '',
                                           'kDeformBendManip': '',
                                           'kDeformFlare': '',
                                           'kDeformFlareManip': '',
                                           'kDeformFunc': '',
                                           'kDeformSine': '',
                                           'kDeformSineManip': '',
                                           'kDeformSquash': '',
                                           'kDeformSquashManip': '',
                                           'kDeformTwist': '',
                                           'kDeformTwistManip': '',
                                           'kDeformWave': '',
                                           'kDeformWaveManip': '',
                                           'kDeleteColorSet': '',
                                           'kDeleteComponent': '',
                                           'kDeleteUVSet': '',
                                           'kDeltaMush': '',
                                           'kDependencyNode': '',
                                           'kDetachCurve': '',
                                           'kDetachSurface': '',
                                           'kDiffuseMaterial': '',
                                           'kDimension': '',
                                           'kDimensionManip': '',
                                           'kDirectedDisc': '',
                                           'kDirectionManip': '',
                                           'kDirectionalLight': '',
                                           'kDiscManip': '',
                                           'kDiskCache': '',
                                           'kDispatchCompute': '',
                                           'kDisplacementShader': '',
                                           'kDisplayLayer': '',
                                           'kDisplayLayerManager': '',
                                           'kDistance': '',
                                           'kDistanceBetween': '',
                                           'kDistanceManip': '',
                                           'kDofManip': '',
                                           'kDoubleAngleAttribute': '',
                                           'kDoubleArrayData': '',
                                           'kDoubleIndexedComponent': '',
                                           'kDoubleLinearAttribute': '',
                                           'kDoubleShadingSwitch': '',
                                           'kDrag': '',
                                           'kDropOffFunction': '',
                                           'kDropoffLocator': '',
                                           'kDropoffManip': '',
                                           'kDummy': '',
                                           'kDummyConnectable': '',
                                           'kDynAirManip': '',
                                           'kDynArrayAttrsData': '',
                                           'kDynAttenuationManip': '',
                                           'kDynBase': '',
                                           'kDynBaseFieldManip': '',
                                           'kDynEmitterManip': '',
                                           'kDynFieldsManip': '',
                                           'kDynGlobals': '',
                                           'kDynNewtonManip': '',
                                           'kDynParticleSetComponent': '',
                                           'kDynSpreadManip': '',
                                           'kDynSweptGeometryData': '',
                                           'kDynTurbulenceManip': '',
                                           'kDynamicConstraint': '',
                                           'kDynamicsController': '',
                                           'kEdgeComponent': '',
                                           'kEditCurve': '',
                                           'kEditCurveManip': '',
                                           'kEditMetadata': 'editMetadata Node',
                                           'kEditsManager': '',
                                           'kEmitter': '',
                                           'kEnableManip': '',
                                           'kEnumAttribute': '',
                                           'kEnvBall': '',
                                           'kEnvChrome': '',
                                           'kEnvCube': '',
                                           'kEnvFacade': '',
                                           'kEnvFogMaterial': '',
                                           'kEnvFogShape': '',
                                           'kEnvSky': '',
                                           'kEnvSphere': '',
                                           'kExplodeNurbsShell': '',
                                           'kExpression': '',
                                           'kExtendCurve': '',
                                           'kExtendCurveDistanceManip': '',
                                           'kExtendSurface': '',
                                           'kExtendSurfaceDistanceManip': '',
                                           'kExtract': '',
                                           'kExtrude': '',
                                           'kExtrudeManip': '',
                                           'kFFD': '',
                                           'kFFblendSrf': '',
                                           'kFFfilletSrf': '',
                                           'kFacade': '',
                                           'kFfdDualBase': '',
                                           'kField': '',
                                           'kFileBackground': '',
                                           'kFileTexture': '',
                                           'kFilletCurve': '',
                                           'kFilter': '',
                                           'kFilterClosestSample': '',
                                           'kFilterEuler': '',
                                           'kFilterSimplify': '',
                                           'kFitBspline': '',
                                           'kFixedLineManip': '',
                                           'kFlexor': '',
                                           'kFloatAngleAttribute': '',
                                           'kFloatArrayData': '',
                                           'kFloatLinearAttribute': '',
                                           'kFloatMatrixAttribute': '',
                                           'kFloatVectorArrayData': '',
                                           'kFlow': '',
                                           'kFluid': '',
                                           'kFluidData': '',
                                           'kFluidEmitter': '',
                                           'kFluidGeom': '',
                                           'kFluidTexture2D': '',
                                           'kFluidTexture3D': '',
                                           'kFollicle': '',
                                           'kForceUpdateManip': '',
                                           'kFosterParent': '',
                                           'kFourByFourMatrix': '',
                                           'kFractal': '',
                                           'kFreePointManip': '',
                                           'kFreePointTriadManip': '',
                                           'kGammaCorrect': '',
                                           'kGenericAttribute': '',
                                           'kGeoConnectable': '',
                                           'kGeoConnector': '',
                                           'kGeomBind': '',
                                           'kGeometric': '',
                                           'kGeometryConstraint': '',
                                           'kGeometryData': '',
                                           'kGeometryFilt': '',
                                           'kGeometryOnLineManip': '',
                                           'kGeometryVarGroup': '',
                                           'kGlobalCacheControls': '',
                                           'kGlobalStitch': '',
                                           'kGranite': '',
                                           'kGravity': '',
                                           'kGreasePencilSequence': '',
                                           'kGreasePlane': '',
                                           'kGreasePlaneRenderShape': '',
                                           'kGrid': '',
                                           'kGroundPlane': '',
                                           'kGroupId': '',
                                           'kGroupParts': '',
                                           'kGuide': '',
                                           'kGuideLine': '',
                                           'kHairConstraint': '',
                                           'kHairSystem': '',
                                           'kHairTubeShader': '',
                                           'kHandleRotateManip': '',
                                           'kHardenPointCurve': '',
                                           'kHardwareReflectionMap': '',
                                           'kHardwareRenderGlobals': '',
                                           'kHardwareRenderingGlobals': '',
                                           'kHeightField': '',
                                           'kHikEffector': '',
                                           'kHikFKJoint': '',
                                           'kHikFloorContactMarker': '',
                                           'kHikGroundPlane': '',
                                           'kHikHandle': '',
                                           'kHikIKEffector': '',
                                           'kHikSolver': '',
                                           'kHistorySwitch': '',
                                           'kHsvToRgb': '',
                                           'kHwShaderNode': '',
                                           'kHyperGraphInfo': '',
                                           'kHyperLayout': '',
                                           'kHyperLayoutDG': '',
                                           'kHyperView': '',
                                           'kIkEffector': '',
                                           'kIkHandle': '',
                                           'kIkRPManip': '',
                                           'kIkSolver': '',
                                           'kIkSplineManip': '',
                                           'kIkSystem': '',
                                           'kIllustratorCurve': '',
                                           'kImageAdd': '',
                                           'kImageBlur': '',
                                           'kImageColorCorrect': '',
                                           'kImageData': '',
                                           'kImageDepth': '',
                                           'kImageDiff': '',
                                           'kImageDisplay': '',
                                           'kImageFilter': '',
                                           'kImageLoad': '',
                                           'kImageMotionBlur': '',
                                           'kImageMultiply': '',
                                           'kImageNetDest': '',
                                           'kImageNetSrc': '',
                                           'kImageOver': '',
                                           'kImagePlane': '',
                                           'kImageRender': '',
                                           'kImageSave': '',
                                           'kImageSource': '',
                                           'kImageUnder': '',
                                           'kImageView': '',
                                           'kImplicitCone': '',
                                           'kImplicitSphere': '',
                                           'kInsertKnotCrv': '',
                                           'kInsertKnotSrf': '',
                                           'kInstancer': '',
                                           'kInt64ArrayData': '',
                                           'kIntArrayData': '',
                                           'kIntersectSurface': '',
                                           'kInvalid': '',
                                           'kIsoparmComponent': '',
                                           'kIsoparmManip': '',
                                           'kItemList': '',
                                           'kJiggleDeformer': '',
                                           'kJoint': '',
                                           'kJointCluster': '',
                                           'kJointClusterManip': '',
                                           'kJointTranslateManip': '',
                                           'kKeyframeDelta': '',
                                           'kKeyframeDeltaAddRemove': '',
                                           'kKeyframeDeltaBlockAddRemove': '',
                                           'kKeyframeDeltaBreakdown': '',
                                           'kKeyframeDeltaInfType': '',
                                           'kKeyframeDeltaMove': '',
                                           'kKeyframeDeltaScale': '',
                                           'kKeyframeDeltaTangent': '',
                                           'kKeyframeDeltaWeighted': '',
                                           'kKeyframeRegionManip': '',
                                           'kLambert': '',
                                           'kLambertMaterial': '',
                                           'kLast': 'Defines the last entry.',
                                           'kLattice': '',
                                           'kLatticeComponent': '',
                                           'kLatticeData': '',
                                           'kLatticeGeom': '',
                                           'kLayeredShader': '',
                                           'kLayeredTexture': '',
                                           'kLeastSquares': '',
                                           'kLeather': '',
                                           'kLight': '',
                                           'kLightDataAttribute': '',
                                           'kLightFogMaterial': '',
                                           'kLightInfo': '',
                                           'kLightLink': '',
                                           'kLightList': '',
                                           'kLightManip': '',
                                           'kLightProjectionGeometry': '',
                                           'kLightSource': '',
                                           'kLightSourceMaterial': '',
                                           'kLimitManip': '',
                                           'kLineArrowManip': '',
                                           'kLineManip': '',
                                           'kLineModifier': '',
                                           'kLinearLight': '',
                                           'kLocator': '',
                                           'kLodGroup': '',
                                           'kLodThresholds': '',
                                           'kLookAt': '',
                                           'kLuminance': '',
                                           'kMCsolver': '',
                                           'kMPbirailSrf': '',
                                           'kMakeGroup': '',
                                           'kMandelbrot': '',
                                           'kMandelbrot3D': '',
                                           'kManip2DContainer': '',
                                           'kManipContainer': '',
                                           'kManipulator': '',
                                           'kManipulator2D': '',
                                           'kManipulator3D': '',
                                           'kMarble': '',
                                           'kMarker': '',
                                           'kMarkerManip': '',
                                           'kMaterial': '',
                                           'kMaterialFacade': '',
                                           'kMaterialInfo': '',
                                           'kMatrixAdd': '',
                                           'kMatrixArrayData': '',
                                           'kMatrixAttribute': '',
                                           'kMatrixData': '',
                                           'kMatrixFloatData': '',
                                           'kMatrixHold': '',
                                           'kMatrixMult': '',
                                           'kMatrixPass': '',
                                           'kMatrixWtAdd': '',
                                           'kMembrane': '',
                                           'kMentalRayTexture': '',
                                           'kMergeVertsToolManip': '',
                                           'kMesh': '',
                                           'kMeshComponent': '',
                                           'kMeshData': '',
                                           'kMeshEdgeComponent': '',
                                           'kMeshFaceVertComponent': '',
                                           'kMeshFrEdgeComponent': '',
                                           'kMeshGeom': '',
                                           'kMeshMapComponent': '',
                                           'kMeshPolygonComponent': '',
                                           'kMeshVarGroup': '',
                                           'kMeshVertComponent': '',
                                           'kMeshVtxFaceComponent': '',
                                           'kMessageAttribute': '',
                                           'kMidModifier': '',
                                           'kMidModifierWithMatrix': '',
                                           'kModel': '',
                                           'kModifyEdgeBaseManip': '',
                                           'kModifyEdgeCrvManip': '',
                                           'kModifyEdgeManip': '',
                                           'kMotionPath': '',
                                           'kMotionPathManip': '',
                                           'kMountain': '',
                                           'kMoveUVShellManip2D': '',
                                           'kMoveVertexManip': '',
                                           'kMultDoubleLinear': '',
                                           'kMultiSubVertexComponent': '',
                                           'kMultilisterLight': '',
                                           'kMultiplyDivide': '',
                                           'kMute': '',
                                           'kNBase': '',
                                           'kNCloth': '',
                                           'kNComponent': '',
                                           'kNId': '',
                                           'kNIdData': '',
                                           'kNLE': 'NLE node.',
                                           'kNObject': '',
                                           'kNObjectData': '',
                                           'kNParticle': '',
                                           'kNRigid': '',
                                           'kNamedObject': '',
                                           'kNearestPointOnCurve': '',
                                           'kNewton': '',
                                           'kNodeGraphEditorBookmarkInfo': '',
                                           'kNodeGraphEditorBookmarks': '',
                                           'kNodeGraphEditorInfo': '',
                                           'kNoise': '',
                                           'kNonAmbientLight': '',
                                           'kNonDagSelectionItem': '',
                                           'kNonExtendedLight': '',
                                           'kNonLinear': '',
                                           'kNormalConstraint': '',
                                           'kNucleus': '',
                                           'kNumericAttribute': '',
                                           'kNumericData': '',
                                           'kNurbsBoolean': '',
                                           'kNurbsCircular2PtArc': '',
                                           'kNurbsCircular3PtArc': '',
                                           'kNurbsCube': '',
                                           'kNurbsCurve': '',
                                           'kNurbsCurveData': '',
                                           'kNurbsCurveGeom': '',
                                           'kNurbsCurveToBezier': '',
                                           'kNurbsPlane': '',
                                           'kNurbsSquare': '',
                                           'kNurbsSurface': '',
                                           'kNurbsSurfaceData': '',
                                           'kNurbsSurfaceGeom': '',
                                           'kNurbsTesselate': '',
                                           'kNurbsToSubdiv': '',
                                           'kObjectAttrFilter': '',
                                           'kObjectBinFilter': '',
                                           'kObjectFilter': '',
                                           'kObjectMultiFilter': '',
                                           'kObjectNameFilter': '',
                                           'kObjectRenderFilter': '',
                                           'kObjectScriptFilter': '',
                                           'kObjectTypeFilter': '',
                                           'kOcean': '',
                                           'kOceanDeformer': '',
                                           'kOceanShader': '',
                                           'kOffsetCos': '',
                                           'kOffsetCosManip': '',
                                           'kOffsetCurve': '',
                                           'kOffsetCurveManip': '',
                                           'kOffsetSurface': '',
                                           'kOffsetSurfaceManip': '',
                                           'kOldGeometryConstraint': '',
                                           'kOpticalFX': '',
                                           'kOrientConstraint': '',
                                           'kOrientationComponent': '',
                                           'kOrientationLocator': '',
                                           'kOrientationMarker': '',
                                           'kOrthoGrid': '',
                                           'kPASolver': '',
                                           'kPairBlend': '',
                                           'kParamDimension': '',
                                           'kParentConstraint': '',
                                           'kParticle': '',
                                           'kParticleAgeMapper': '',
                                           'kParticleCloud': '',
                                           'kParticleColorMapper': '',
                                           'kParticleIncandecenceMapper': '',
                                           'kParticleSamplerInfo': '',
                                           'kParticleTransparencyMapper': '',
                                           'kPartition': '',
                                           'kPassContributionMap': '',
                                           'kPfxGeometry': '',
                                           'kPfxHair': '',
                                           'kPfxToon': '',
                                           'kPhong': '',
                                           'kPhongExplorer': '',
                                           'kPhongMaterial': '',
                                           'kPivotComponent': '',
                                           'kPivotManip2D': '',
                                           'kPlace2dTexture': '',
                                           'kPlace3dTexture': '',
                                           'kPlanarProjectionManip': '',
                                           'kPlanarTrimSrf': '',
                                           'kPlane': '',
                                           'kPlugin': 'Custom Plug-in.',
                                           'kPluginBlendShape': 'Custom deformer node derived from',
                                           'kPluginCameraSet': 'Custom cameraSet nodes (dependency nodes) derived from',
                                           'kPluginClientDevice': '',
                                           'kPluginConstraintNode': 'Custom constraint node derived from',
                                           'kPluginData': 'Custom data types derived from',
                                           'kPluginDeformerNode': 'Custom deformer node derived from',
                                           'kPluginDependNode': 'Custom dependency nodes derived from',
                                           'kPluginEmitterNode': 'Custom dependency graph node representing an emitter derived from',
                                           'kPluginFieldNode': 'Custom dependency graph node representing a field derived from',
                                           'kPluginGeometryData': 'Custom container for arbitrary Geometry type derived from',
                                           'kPluginGeometryFilter': 'Custom deformer node derived from',
                                           'kPluginHardwareShader': 'Custom hardware shader derived from',
                                           'kPluginHwShaderNode': 'Custom hardware shader derived from',
                                           'kPluginIkSolver': 'Custom IK Solvers derived from',
                                           'kPluginImagePlaneNode': 'Custom Image Plane classes derived from',
                                           'kPluginLocatorNode': 'Custom locator node derived from',
                                           'kPluginManipContainer': 'Custom manipulator containers derived from',
                                           'kPluginManipulatorNode': 'Custom manipulator node derived from',
                                           'kPluginMotionPathNode': 'Custom motionPath nodes derived from',
                                           'kPluginObjectSet': 'Custom sets (dependency nodes) derived from',
                                           'kPluginParticleAttributeMapperNode': '',
                                           'kPluginShape': 'Custom shapes (dependency nodes) derived from',
                                           'kPluginSkinCluster': 'Custom deformer node derived from',
                                           'kPluginSpringNode': 'Custom dependency graph node representing a spring derived from',
                                           'kPluginThreadedDevice': '',
                                           'kPluginTransformNode': 'Custom transform node derived from',
                                           'kPlusMinusAverage': '',
                                           'kPointArrayData': '',
                                           'kPointConstraint': '',
                                           'kPointLight': '',
                                           'kPointManip': '',
                                           'kPointMatrixMult': '',
                                           'kPointOnCurveInfo': '',
                                           'kPointOnCurveManip': '',
                                           'kPointOnLineManip': '',
                                           'kPointOnPolyConstraint': '',
                                           'kPointOnSurfaceInfo': '',
                                           'kPointOnSurfaceManip': '',
                                           'kPoleVectorConstraint': '',
                                           'kPolyAppend': '',
                                           'kPolyAppendVertex': '',
                                           'kPolyArrow': '',
                                           'kPolyAutoProj': '',
                                           'kPolyAutoProjManip': '',
                                           'kPolyAverageVertex': '',
                                           'kPolyBevel': '',
                                           'kPolyBevel2': '',
                                           'kPolyBevel3': '',
                                           'kPolyBlindData': '',
                                           'kPolyBoolOp': '',
                                           'kPolyBridgeEdge': '',
                                           'kPolyCBoolOp': 'Carve Booleans Node.',
                                           'kPolyCaddyManip': '',
                                           'kPolyChipOff': '',
                                           'kPolyCircularize': '',
                                           'kPolyClean': '',
                                           'kPolyCloseBorder': '',
                                           'kPolyCollapseEdge': '',
                                           'kPolyCollapseF': '',
                                           'kPolyColorDel': '',
                                           'kPolyColorMod': '',
                                           'kPolyColorPerVertex': '',
                                           'kPolyComponentData': '',
                                           'kPolyCone': '',
                                           'kPolyConnectComponents': '',
                                           'kPolyContourProj': '',
                                           'kPolyCreaseEdge': '',
                                           'kPolyCreateFacet': '',
                                           'kPolyCreateToolManip': '',
                                           'kPolyCreator': '',
                                           'kPolyCube': '',
                                           'kPolyCut': '',
                                           'kPolyCutManip': '',
                                           'kPolyCutManipContainer': '',
                                           'kPolyCylProj': '',
                                           'kPolyCylinder': '',
                                           'kPolyDelEdge': '',
                                           'kPolyDelFacet': '',
                                           'kPolyDelVertex': '',
                                           'kPolyDuplicateEdge': '',
                                           'kPolyEdgeToCurve': '',
                                           'kPolyEditEdgeFlow': 'Edit Edge Flow History Node.',
                                           'kPolyExtrudeEdge': '',
                                           'kPolyExtrudeFacet': '',
                                           'kPolyExtrudeManip': '',
                                           'kPolyExtrudeManipContainer': '',
                                           'kPolyExtrudeVertex': '',
                                           'kPolyFlipEdge': '',
                                           'kPolyFlipUV': '',
                                           'kPolyHelix': '',
                                           'kPolyHoleFace': '',
                                           'kPolyLayoutUV': '',
                                           'kPolyMapCut': '',
                                           'kPolyMapDel': '',
                                           'kPolyMapSew': '',
                                           'kPolyMapSewMove': '',
                                           'kPolyMappingManip': '',
                                           'kPolyMergeEdge': '',
                                           'kPolyMergeFacet': '',
                                           'kPolyMergeUV': '',
                                           'kPolyMergeVert': '',
                                           'kPolyMesh': '',
                                           'kPolyMirror': '',
                                           'kPolyMirrorManipContainer': '',
                                           'kPolyModifierManip': '',
                                           'kPolyModifierManipContainer': '',
                                           'kPolyMoveEdge': '',
                                           'kPolyMoveFacet': '',
                                           'kPolyMoveFacetUV': '',
                                           'kPolyMoveUV': '',
                                           'kPolyMoveUVManip': '',
                                           'kPolyMoveVertex': '',
                                           'kPolyMoveVertexManip': '',
                                           'kPolyMoveVertexUV': '',
                                           'kPolyNormal': '',
                                           'kPolyNormalPerVertex': '',
                                           'kPolyNormalizeUV': '',
                                           'kPolyPinUV': '',
                                           'kPolyPipe': '',
                                           'kPolyPlanProj': '',
                                           'kPolyPlatonicSolid': '',
                                           'kPolyPoke': '',
                                           'kPolyPokeManip': '',
                                           'kPolyPrimitive': '',
                                           'kPolyPrimitiveMisc': '',
                                           'kPolyPrism': '',
                                           'kPolyProj': '',
                                           'kPolyProjectCurve': '',
                                           'kPolyProjectionManip': '',
                                           'kPolyPyramid': '',
                                           'kPolyQuad': '',
                                           'kPolyReduce': '',
                                           'kPolyRemesh': '',
                                           'kPolySelectEditFeedbackManip': '',
                                           'kPolySeparate': '',
                                           'kPolySewEdge': '',
                                           'kPolySmooth': '',
                                           'kPolySmoothFacet': '',
                                           'kPolySmoothProxy': '',
                                           'kPolySoftEdge': '',
                                           'kPolySphProj': '',
                                           'kPolySphere': '',
                                           'kPolySpinEdge': '',
                                           'kPolySplit': '',
                                           'kPolySplitEdge': '',
                                           'kPolySplitRing': '',
                                           'kPolySplitToolManip': '',
                                           'kPolySplitVert': '',
                                           'kPolyStraightenUVBorder': '',
                                           'kPolySubdEdge': '',
                                           'kPolySubdFacet': '',
                                           'kPolyToSubdiv': '',
                                           'kPolyToolFeedbackManip': '',
                                           'kPolyToolFeedbackShape': '',
                                           'kPolyTorus': '',
                                           'kPolyTransfer': '',
                                           'kPolyTriangulate': '',
                                           'kPolyTweak': '',
                                           'kPolyTweakUV': '',
                                           'kPolyUVRectangle': '',
                                           'kPolyUnite': '',
                                           'kPolyVertexNormalManip': '',
                                           'kPolyWedgeFace': '',
                                           'kPoseInterpolatorManager': '',
                                           'kPositionMarker': '',
                                           'kPostProcessList': '',
                                           'kPrecompExport': '',
                                           'kPrimitive': '',
                                           'kProjectCurve': '',
                                           'kProjectTangent': '',
                                           'kProjectTangentManip': '',
                                           'kProjection': '',
                                           'kProjectionManip': '',
                                           'kProjectionMultiManip': '',
                                           'kProjectionUVManip': '',
                                           'kPropModManip': '',
                                           'kPropMoveTriadManip': '',
                                           'kProxWrap': '',
                                           'kProxy': '',
                                           'kProxyManager': '',
                                           'kPsdFileTexture': '',
                                           'kQuadPtOnLineManip': '',
                                           'kQuadShadingSwitch': '',
                                           'kRBFsurface': '',
                                           'kRPsolver': '',
                                           'kRadial': '',
                                           'kRadius': '',
                                           'kRamp': '',
                                           'kRampBackground': '',
                                           'kRampShader': '',
                                           'kRbfSrfManip': '',
                                           'kReForm': '',
                                           'kRebuildCurve': '',
                                           'kRebuildSurface': '',
                                           'kRecord': '',
                                           'kReference': '',
                                           'kReflect': '',
                                           'kRemapColor': '',
                                           'kRemapHsv': '',
                                           'kRemapValue': '',
                                           'kRenderBox': '',
                                           'kRenderCone': '',
                                           'kRenderGlobals': '',
                                           'kRenderGlobalsList': '',
                                           'kRenderLayer': '',
                                           'kRenderLayerManager': '',
                                           'kRenderPass': '',
                                           'kRenderPassSet': '',
                                           'kRenderQuality': '',
                                           'kRenderRect': '',
                                           'kRenderSetup': '',
                                           'kRenderSphere': '',
                                           'kRenderTarget': '',
                                           'kRenderUtilityList': '',
                                           'kRenderedImageSource': '',
                                           'kRenderingList': '',
                                           'kResolution': '',
                                           'kResultCurve': '',
                                           'kResultCurveTimeToAngular': '',
                                           'kResultCurveTimeToDistance': '',
                                           'kResultCurveTimeToTime': '',
                                           'kResultCurveTimeToUnitless': '',
                                           'kReverse': '',
                                           'kReverseCrvManip': '',
                                           'kReverseCurve': '',
                                           'kReverseCurveManip': '',
                                           'kReverseSurface': '',
                                           'kReverseSurfaceManip': '',
                                           'kRevolve': '',
                                           'kRevolveManip': '',
                                           'kRevolvedPrimitive': '',
                                           'kRevolvedPrimitiveManip': '',
                                           'kRgbToHsv': '',
                                           'kRigid': '',
                                           'kRigidConstraint': '',
                                           'kRigidDeform': '',
                                           'kRigidSolver': '',
                                           'kRock': '',
                                           'kRotateBoxManip': '',
                                           'kRotateLimitsManip': '',
                                           'kRotateManip': '',
                                           'kRotateUVManip2D': '',
                                           'kRoundConstantRadius': '',
                                           'kRoundConstantRadiusManip': '',
                                           'kRoundRadiusCrvManip': '',
                                           'kRoundRadiusManip': '',
                                           'kSCsolver': '',
                                           'kSPbirailSrf': '',
                                           'kSamplerInfo': '',
                                           'kScaleConstraint': '',
                                           'kScaleLimitsManip': '',
                                           'kScaleManip': '',
                                           'kScalePointManip': '',
                                           'kScaleUVManip2D': '',
                                           'kScalingBoxManip': '',
                                           'kScreenAlignedCircleManip': '',
                                           'kScript': '',
                                           'kScriptManip': '',
                                           'kSculpt': '',
                                           'kSectionManip': '',
                                           'kSelectionItem': '',
                                           'kSelectionList': '',
                                           'kSelectionListData': '',
                                           'kSelectionListOperator': '',
                                           'kSet': '',
                                           'kSetGroupComponent': '',
                                           'kSetRange': '',
                                           'kSfRevolveManip': '',
                                           'kShaderGlow': '',
                                           'kShaderList': '',
                                           'kShadingEngine': '',
                                           'kShadingMap': '',
                                           'kShape': '',
                                           'kShapeEditorManager': '',
                                           'kShapeFragment': '',
                                           'kShrinkWrapFilter': '',
                                           'kSimpleVolumeShader': '',
                                           'kSingleIndexedComponent': '',
                                           'kSingleShadingSwitch': '',
                                           'kSketchPlane': '',
                                           'kSkin': '',
                                           'kSkinBinding': '',
                                           'kSkinClusterFilter': '',
                                           'kSkinShader': '',
                                           'kSl60': '',
                                           'kSmear': '',
                                           'kSmoothCurve': '',
                                           'kSmoothTangentSrf': '',
                                           'kSnapUVManip2D': '',
                                           'kSnapshot': '',
                                           'kSnapshotPath': '',
                                           'kSnapshotShape': '',
                                           'kSnow': '',
                                           'kSoftMod': '',
                                           'kSoftModFilter': '',
                                           'kSoftModManip': '',
                                           'kSolidFractal': '',
                                           'kSphere': '',
                                           'kSphereData': '',
                                           'kSphericalProjectionManip': '',
                                           'kSplineSolver': '',
                                           'kSpotCylinderManip': '',
                                           'kSpotLight': '',
                                           'kSpotManip': '',
                                           'kSpring': '',
                                           'kSprite': '',
                                           'kSquareSrf': '',
                                           'kSquareSrfManip': '',
                                           'kStateManip': '',
                                           'kStencil': '',
                                           'kStereoCameraMaster': 'Master node for a stereo camera rig.',
                                           'kStitchAsNurbsShell': '',
                                           'kStitchSrf': '',
                                           'kStitchSrfManip': '',
                                           'kStoryBoard': '',
                                           'kStringArrayData': '',
                                           'kStringData': '',
                                           'kStringShadingSwitch': '',
                                           'kStroke': '',
                                           'kStrokeGlobals': '',
                                           'kStucco': '',
                                           'kStudioClearCoat': '',
                                           'kStyleCurve': '',
                                           'kSubCurve': '',
                                           'kSubSurface': '',
                                           'kSubVertexComponent': '',
                                           'kSubdAddTopology': '',
                                           'kSubdAutoProj': '',
                                           'kSubdBlindData': '',
                                           'kSubdBoolean': '',
                                           'kSubdCleanTopology': '',
                                           'kSubdCloseBorder': '',
                                           'kSubdDelFace': '',
                                           'kSubdExtrudeFace': '',
                                           'kSubdHierBlind': '',
                                           'kSubdLayoutUV': '',
                                           'kSubdMapCut': '',
                                           'kSubdMapSewMove': '',
                                           'kSubdMappingManip': '',
                                           'kSubdMergeVert': '',
                                           'kSubdModifier': '',
                                           'kSubdModifyEdge': '',
                                           'kSubdMoveEdge': '',
                                           'kSubdMoveFace': '',
                                           'kSubdMoveVertex': '',
                                           'kSubdPlanProj': '',
                                           'kSubdProjectionManip': '',
                                           'kSubdSplitFace': '',
                                           'kSubdSubdivideFace': '',
                                           'kSubdTweak': '',
                                           'kSubdTweakUV': '',
                                           'kSubdiv': '',
                                           'kSubdivCVComponent': '',
                                           'kSubdivCollapse': '',
                                           'kSubdivCompId': '',
                                           'kSubdivData': '',
                                           'kSubdivEdgeComponent': '',
                                           'kSubdivFaceComponent': '',
                                           'kSubdivGeom': '',
                                           'kSubdivMapComponent': '',
                                           'kSubdivReverseFaces': '',
                                           'kSubdivSurfaceVarGroup': '',
                                           'kSubdivToNurbs': '',
                                           'kSubdivToPoly': '',
                                           'kSummaryObject': '',
                                           'kSuper': '',
                                           'kSurface': '',
                                           'kSurfaceCVComponent': '',
                                           'kSurfaceEPComponent': '',
                                           'kSurfaceEdManip': '',
                                           'kSurfaceFaceComponent': '',
                                           'kSurfaceInfo': '',
                                           'kSurfaceKnotComponent': '',
                                           'kSurfaceLuminance': '',
                                           'kSurfaceRangeComponent': '',
                                           'kSurfaceShader': '',
                                           'kSurfaceVarGroup': '',
                                           'kSymmetryConstraint': '',
                                           'kSymmetryLocator': '',
                                           'kSymmetryMapCurve': '',
                                           'kSymmetryMapVector': '',
                                           'kTangentConstraint': '',
                                           'kTension': '',
                                           'kTexLattice': '',
                                           'kTexLatticeDeformManip': '',
                                           'kTexSmoothManip': '',
                                           'kTexSmudgeUVManip': '',
                                           'kTextButtonManip': '',
                                           'kTextCurves': '',
                                           'kTextManip': '',
                                           'kTexture2d': '',
                                           'kTexture3d': '',
                                           'kTextureBakeSet': '',
                                           'kTextureDeformer': '',
                                           'kTextureDeformerHandle': '',
                                           'kTextureEnv': '',
                                           'kTextureList': '',
                                           'kTextureManip3D': '',
                                           'kThreadedDevice': '',
                                           'kThreePointArcManip': '',
                                           'kTime': '',
                                           'kTimeAttribute': '',
                                           'kTimeEditor': '',
                                           'kTimeEditorAnimSource': '',
                                           'kTimeEditorClip': '',
                                           'kTimeEditorClipBase': '',
                                           'kTimeEditorClipEvaluator': '',
                                           'kTimeEditorInterpolator': '',
                                           'kTimeEditorTracks': '',
                                           'kTimeFunction': '',
                                           'kTimeToUnitConversion': '',
                                           'kTimeWarp': '',
                                           'kToggleManip': '',
                                           'kToggleOnLineManip': '',
                                           'kToolContext': 'Tool context.',
                                           'kToonLineAttributes': '',
                                           'kTorus': '',
                                           'kTowPointManip': '',
                                           'kTowPointOnCurveManip': '',
                                           'kTowPointOnSurfaceManip': '',
                                           'kTrackInfoManager': '',
                                           'kTransferAttributes': '',
                                           'kTransform': '',
                                           'kTransformBoxManip': '',
                                           'kTransformGeometry': '',
                                           'kTranslateBoxManip': '',
                                           'kTranslateLimitsManip': '',
                                           'kTranslateManip': '',
                                           'kTranslateManip2D': '',
                                           'kTranslateUVManip': '',
                                           'kTranslateUVManip2D': '',
                                           'kTriadManip': '',
                                           'kTrim': '',
                                           'kTrimLocator': '',
                                           'kTrimManip': '',
                                           'kTrimWithBoundaries': '',
                                           'kTriplanarProjectionManip': '',
                                           'kTripleIndexedComponent': '',
                                           'kTripleShadingSwitch': '',
                                           'kTrsInsertManip': '',
                                           'kTrsManip': '',
                                           'kTrsTransManip': '',
                                           'kTrsXformManip': '',
                                           'kTurbulence': '',
                                           'kTweak': '',
                                           'kTwoPointArcManip': '',
                                           'kTxSl': '',
                                           'kTypedAttribute': '',
                                           'kUInt64ArrayData': '',
                                           'kUVManip2D': '',
                                           'kUint64SingleIndexedComponent': '',
                                           'kUnderWorld': '',
                                           'kUniform': '',
                                           'kUnitAttribute': '',
                                           'kUnitConversion': '',
                                           'kUnitToTimeConversion': '',
                                           'kUnknown': '',
                                           'kUnknownDag': '',
                                           'kUnknownTransform': '',
                                           'kUntrim': '',
                                           'kUnused1': '',
                                           'kUnused2': '',
                                           'kUnused3': '',
                                           'kUnused4': '',
                                           'kUnused5': '',
                                           'kUnused6': '',
                                           'kUseBackground': '',
                                           'kUvChooser': '',
                                           'kVectorArrayData': '',
                                           'kVectorProduct': '',
                                           'kVertexBakeSet': '',
                                           'kVertexWeightSet': '',
                                           'kViewColorManager': '',
                                           'kViewManip': '',
                                           'kVolumeAxis': '',
                                           'kVolumeBindManip': '',
                                           'kVolumeFog': '',
                                           'kVolumeLight': '',
                                           'kVolumeNoise': '',
                                           'kVolumeShader': '',
                                           'kVortex': '',
                                           'kWater': '',
                                           'kWeightGeometryFilt': '',
                                           'kWire': '',
                                           'kWood': '',
                                           'kWorld': '',
                                           'kWrapFilter': '',
                                           'kWriteToColorBuffer': '',
                                           'kWriteToDepthBuffer': '',
                                           'kWriteToFrameBuffer': '',
                                           'kWriteToLabelBuffer': '',
                                           'kWriteToVectorBuffer': '',
                                           'kXformManip': '',
                                           'kXsectionSubdivEdit': '',
                                           'keyframeDelta': '',
                                           'keyframeDeltaAddRemove': '',
                                           'keyframeDeltaBlockAddRemove': '',
                                           'keyframeDeltaBreakdown': '',
                                           'keyframeDeltaInfType': '',
                                           'keyframeDeltaMove': '',
                                           'keyframeDeltaScale': '',
                                           'keyframeDeltaTangent': '',
                                           'keyframeDeltaWeighted': '',
                                           'keyframeRegionManip': '',
                                           'lambert': '',
                                           'lambertMaterial': '',
                                           'last': 'Defines the last entry.',
                                           'lattice': '',
                                           'latticeComponent': '',
                                           'latticeData': '',
                                           'latticeGeom': '',
                                           'layeredShader': '',
                                           'layeredTexture': '',
                                           'leastSquares': '',
                                           'leather': '',
                                           'light': '',
                                           'lightDataAttribute': '',
                                           'lightFogMaterial': '',
                                           'lightInfo': '',
                                           'lightLink': '',
                                           'lightList': '',
                                           'lightManip': '',
                                           'lightProjectionGeometry': '',
                                           'lightSource': '',
                                           'lightSourceMaterial': '',
                                           'limitManip': '',
                                           'lineArrowManip': '',
                                           'lineManip': '',
                                           'lineModifier': '',
                                           'linearLight': '',
                                           'locator': '',
                                           'lodGroup': '',
                                           'lodThresholds': '',
                                           'lookAt': '',
                                           'luminance': '',
                                           'makeGroup': '',
                                           'mandelbrot': '',
                                           'mandelbrot3D': '',
                                           'manip2DContainer': '',
                                           'manipContainer': '',
                                           'manipulator': '',
                                           'manipulator2D': '',
                                           'manipulator3D': '',
                                           'marble': '',
                                           'marker': '',
                                           'markerManip': '',
                                           'material': '',
                                           'materialFacade': '',
                                           'materialInfo': '',
                                           'matrixAdd': '',
                                           'matrixArrayData': '',
                                           'matrixAttribute': '',
                                           'matrixData': '',
                                           'matrixFloatData': '',
                                           'matrixHold': '',
                                           'matrixMult': '',
                                           'matrixPass': '',
                                           'matrixWtAdd': '',
                                           'membrane': '',
                                           'mentalRayTexture': '',
                                           'mergeVertsToolManip': '',
                                           'mesh': '',
                                           'meshComponent': '',
                                           'meshData': '',
                                           'meshEdgeComponent': '',
                                           'meshFaceVertComponent': '',
                                           'meshFrEdgeComponent': '',
                                           'meshGeom': '',
                                           'meshMapComponent': '',
                                           'meshPolygonComponent': '',
                                           'meshVarGroup': '',
                                           'meshVertComponent': '',
                                           'meshVtxFaceComponent': '',
                                           'messageAttribute': '',
                                           'midModifier': '',
                                           'midModifierWithMatrix': '',
                                           'model': '',
                                           'modifyEdgeBaseManip': '',
                                           'modifyEdgeCrvManip': '',
                                           'modifyEdgeManip': '',
                                           'motionPath': '',
                                           'motionPathManip': '',
                                           'mountain': '',
                                           'moveUVShellManip2D': '',
                                           'moveVertexManip': '',
                                           'multDoubleLinear': '',
                                           'multiSubVertexComponent': '',
                                           'multilisterLight': '',
                                           'multiplyDivide': '',
                                           'mute': '',
                                           'namedObject': '',
                                           'nearestPointOnCurve': '',
                                           'newton': '',
                                           'nodeGraphEditorBookmarkInfo': '',
                                           'nodeGraphEditorBookmarks': '',
                                           'nodeGraphEditorInfo': '',
                                           'noise': '',
                                           'nonAmbientLight': '',
                                           'nonDagSelectionItem': '',
                                           'nonExtendedLight': '',
                                           'nonLinear': '',
                                           'normalConstraint': '',
                                           'nucleus': '',
                                           'numericAttribute': '',
                                           'numericData': '',
                                           'nurbsBoolean': '',
                                           'nurbsCircular2PtArc': '',
                                           'nurbsCircular3PtArc': '',
                                           'nurbsCube': '',
                                           'nurbsCurve': '',
                                           'nurbsCurveData': '',
                                           'nurbsCurveGeom': '',
                                           'nurbsCurveToBezier': '',
                                           'nurbsPlane': '',
                                           'nurbsSquare': '',
                                           'nurbsSurface': '',
                                           'nurbsSurfaceData': '',
                                           'nurbsSurfaceGeom': '',
                                           'nurbsTesselate': '',
                                           'nurbsToSubdiv': '',
                                           'objectAttrFilter': '',
                                           'objectBinFilter': '',
                                           'objectFilter': '',
                                           'objectMultiFilter': '',
                                           'objectNameFilter': '',
                                           'objectRenderFilter': '',
                                           'objectScriptFilter': '',
                                           'objectTypeFilter': '',
                                           'ocean': '',
                                           'oceanDeformer': '',
                                           'oceanShader': '',
                                           'offsetCos': '',
                                           'offsetCosManip': '',
                                           'offsetCurve': '',
                                           'offsetCurveManip': '',
                                           'offsetSurface': '',
                                           'offsetSurfaceManip': '',
                                           'oldGeometryConstraint': '',
                                           'opticalFX': '',
                                           'orientConstraint': '',
                                           'orientationComponent': '',
                                           'orientationLocator': '',
                                           'orientationMarker': '',
                                           'orthoGrid': '',
                                           'pairBlend': '',
                                           'paramDimension': '',
                                           'parentConstraint': '',
                                           'particle': '',
                                           'particleAgeMapper': '',
                                           'particleCloud': '',
                                           'particleColorMapper': '',
                                           'particleIncandecenceMapper': '',
                                           'particleSamplerInfo': '',
                                           'particleTransparencyMapper': '',
                                           'partition': '',
                                           'passContributionMap': '',
                                           'pfxGeometry': '',
                                           'pfxHair': '',
                                           'pfxToon': '',
                                           'phong': '',
                                           'phongExplorer': '',
                                           'phongMaterial': '',
                                           'pivotComponent': '',
                                           'pivotManip2D': '',
                                           'place2dTexture': '',
                                           'place3dTexture': '',
                                           'planarProjectionManip': '',
                                           'planarTrimSrf': '',
                                           'plane': '',
                                           'plugin': 'Custom Plug-in.',
                                           'pluginBlendShape': 'Custom deformer node derived from',
                                           'pluginCameraSet': 'Custom cameraSet nodes (dependency nodes) derived from',
                                           'pluginClientDevice': '',
                                           'pluginConstraintNode': 'Custom constraint node derived from',
                                           'pluginData': 'Custom data types derived from',
                                           'pluginDeformerNode': 'Custom deformer node derived from',
                                           'pluginDependNode': 'Custom dependency nodes derived from',
                                           'pluginEmitterNode': 'Custom dependency graph node representing an emitter derived from',
                                           'pluginFieldNode': 'Custom dependency graph node representing a field derived from',
                                           'pluginGeometryData': 'Custom container for arbitrary Geometry type derived from',
                                           'pluginGeometryFilter': 'Custom deformer node derived from',
                                           'pluginHardwareShader': 'Custom hardware shader derived from',
                                           'pluginHwShaderNode': 'Custom hardware shader derived from',
                                           'pluginIkSolver': 'Custom IK Solvers derived from',
                                           'pluginImagePlaneNode': 'Custom Image Plane classes derived from',
                                           'pluginLocatorNode': 'Custom locator node derived from',
                                           'pluginManipContainer': 'Custom manipulator containers derived from',
                                           'pluginManipulatorNode': 'Custom manipulator node derived from',
                                           'pluginMotionPathNode': 'Custom motionPath nodes derived from',
                                           'pluginObjectSet': 'Custom sets (dependency nodes) derived from',
                                           'pluginParticleAttributeMapperNode': '',
                                           'pluginShape': 'Custom shapes (dependency nodes) derived from',
                                           'pluginSkinCluster': 'Custom deformer node derived from',
                                           'pluginSpringNode': 'Custom dependency graph node representing a spring derived from',
                                           'pluginThreadedDevice': '',
                                           'pluginTransformNode': 'Custom transform node derived from',
                                           'plusMinusAverage': '',
                                           'pointArrayData': '',
                                           'pointConstraint': '',
                                           'pointLight': '',
                                           'pointManip': '',
                                           'pointMatrixMult': '',
                                           'pointOnCurveInfo': '',
                                           'pointOnCurveManip': '',
                                           'pointOnLineManip': '',
                                           'pointOnPolyConstraint': '',
                                           'pointOnSurfaceInfo': '',
                                           'pointOnSurfaceManip': '',
                                           'poleVectorConstraint': '',
                                           'polyAppend': '',
                                           'polyAppendVertex': '',
                                           'polyArrow': '',
                                           'polyAutoProj': '',
                                           'polyAutoProjManip': '',
                                           'polyAverageVertex': '',
                                           'polyBevel': '',
                                           'polyBevel2': '',
                                           'polyBevel3': '',
                                           'polyBlindData': '',
                                           'polyBoolOp': '',
                                           'polyBridgeEdge': '',
                                           'polyCBoolOp': 'Carve Booleans Node.',
                                           'polyCaddyManip': '',
                                           'polyChipOff': '',
                                           'polyCircularize': '',
                                           'polyClean': '',
                                           'polyCloseBorder': '',
                                           'polyCollapseEdge': '',
                                           'polyCollapseF': '',
                                           'polyColorDel': '',
                                           'polyColorMod': '',
                                           'polyColorPerVertex': '',
                                           'polyComponentData': '',
                                           'polyCone': '',
                                           'polyConnectComponents': '',
                                           'polyContourProj': '',
                                           'polyCreaseEdge': '',
                                           'polyCreateFacet': '',
                                           'polyCreateToolManip': '',
                                           'polyCreator': '',
                                           'polyCube': '',
                                           'polyCut': '',
                                           'polyCutManip': '',
                                           'polyCutManipContainer': '',
                                           'polyCylProj': '',
                                           'polyCylinder': '',
                                           'polyDelEdge': '',
                                           'polyDelFacet': '',
                                           'polyDelVertex': '',
                                           'polyDuplicateEdge': '',
                                           'polyEdgeToCurve': '',
                                           'polyEditEdgeFlow': 'Edit Edge Flow History Node.',
                                           'polyExtrudeEdge': '',
                                           'polyExtrudeFacet': '',
                                           'polyExtrudeManip': '',
                                           'polyExtrudeManipContainer': '',
                                           'polyExtrudeVertex': '',
                                           'polyFlipEdge': '',
                                           'polyFlipUV': '',
                                           'polyHelix': '',
                                           'polyHoleFace': '',
                                           'polyLayoutUV': '',
                                           'polyMapCut': '',
                                           'polyMapDel': '',
                                           'polyMapSew': '',
                                           'polyMapSewMove': '',
                                           'polyMappingManip': '',
                                           'polyMergeEdge': '',
                                           'polyMergeFacet': '',
                                           'polyMergeUV': '',
                                           'polyMergeVert': '',
                                           'polyMesh': '',
                                           'polyMirror': '',
                                           'polyMirrorManipContainer': '',
                                           'polyModifierManip': '',
                                           'polyModifierManipContainer': '',
                                           'polyMoveEdge': '',
                                           'polyMoveFacet': '',
                                           'polyMoveFacetUV': '',
                                           'polyMoveUV': '',
                                           'polyMoveUVManip': '',
                                           'polyMoveVertex': '',
                                           'polyMoveVertexManip': '',
                                           'polyMoveVertexUV': '',
                                           'polyNormal': '',
                                           'polyNormalPerVertex': '',
                                           'polyNormalizeUV': '',
                                           'polyPinUV': '',
                                           'polyPipe': '',
                                           'polyPlanProj': '',
                                           'polyPlatonicSolid': '',
                                           'polyPoke': '',
                                           'polyPokeManip': '',
                                           'polyPrimitive': '',
                                           'polyPrimitiveMisc': '',
                                           'polyPrism': '',
                                           'polyProj': '',
                                           'polyProjectCurve': '',
                                           'polyProjectionManip': '',
                                           'polyPyramid': '',
                                           'polyQuad': '',
                                           'polyReduce': '',
                                           'polyRemesh': '',
                                           'polySelectEditFeedbackManip': '',
                                           'polySeparate': '',
                                           'polySewEdge': '',
                                           'polySmooth': '',
                                           'polySmoothFacet': '',
                                           'polySmoothProxy': '',
                                           'polySoftEdge': '',
                                           'polySphProj': '',
                                           'polySphere': '',
                                           'polySpinEdge': '',
                                           'polySplit': '',
                                           'polySplitEdge': '',
                                           'polySplitRing': '',
                                           'polySplitToolManip': '',
                                           'polySplitVert': '',
                                           'polyStraightenUVBorder': '',
                                           'polySubdEdge': '',
                                           'polySubdFacet': '',
                                           'polyToSubdiv': '',
                                           'polyToolFeedbackManip': '',
                                           'polyToolFeedbackShape': '',
                                           'polyTorus': '',
                                           'polyTransfer': '',
                                           'polyTriangulate': '',
                                           'polyTweak': '',
                                           'polyTweakUV': '',
                                           'polyUVRectangle': '',
                                           'polyUnite': '',
                                           'polyVertexNormalManip': '',
                                           'polyWedgeFace': '',
                                           'poseInterpolatorManager': '',
                                           'positionMarker': '',
                                           'postProcessList': '',
                                           'precompExport': '',
                                           'primitive': '',
                                           'projectCurve': '',
                                           'projectTangent': '',
                                           'projectTangentManip': '',
                                           'projection': '',
                                           'projectionManip': '',
                                           'projectionMultiManip': '',
                                           'projectionUVManip': '',
                                           'propModManip': '',
                                           'propMoveTriadManip': '',
                                           'proxWrap': '',
                                           'proxy': '',
                                           'proxyManager': '',
                                           'psdFileTexture': '',
                                           'quadPtOnLineManip': '',
                                           'quadShadingSwitch': '',
                                           'radial': '',
                                           'radius': '',
                                           'ramp': '',
                                           'rampBackground': '',
                                           'rampShader': '',
                                           'rbfSrfManip': '',
                                           'reForm': '',
                                           'rebuildCurve': '',
                                           'rebuildSurface': '',
                                           'record': '',
                                           'reference': '',
                                           'reflect': '',
                                           'remapColor': '',
                                           'remapHsv': '',
                                           'remapValue': '',
                                           'renderBox': '',
                                           'renderCone': '',
                                           'renderGlobals': '',
                                           'renderGlobalsList': '',
                                           'renderLayer': '',
                                           'renderLayerManager': '',
                                           'renderPass': '',
                                           'renderPassSet': '',
                                           'renderQuality': '',
                                           'renderRect': '',
                                           'renderSetup': '',
                                           'renderSphere': '',
                                           'renderTarget': '',
                                           'renderUtilityList': '',
                                           'renderedImageSource': '',
                                           'renderingList': '',
                                           'resolution': '',
                                           'resultCurve': '',
                                           'resultCurveTimeToAngular': '',
                                           'resultCurveTimeToDistance': '',
                                           'resultCurveTimeToTime': '',
                                           'resultCurveTimeToUnitless': '',
                                           'reverse': '',
                                           'reverseCrvManip': '',
                                           'reverseCurve': '',
                                           'reverseCurveManip': '',
                                           'reverseSurface': '',
                                           'reverseSurfaceManip': '',
                                           'revolve': '',
                                           'revolveManip': '',
                                           'revolvedPrimitive': '',
                                           'revolvedPrimitiveManip': '',
                                           'rgbToHsv': '',
                                           'rigid': '',
                                           'rigidConstraint': '',
                                           'rigidDeform': '',
                                           'rigidSolver': '',
                                           'rock': '',
                                           'rotateBoxManip': '',
                                           'rotateLimitsManip': '',
                                           'rotateManip': '',
                                           'rotateUVManip2D': '',
                                           'roundConstantRadius': '',
                                           'roundConstantRadiusManip': '',
                                           'roundRadiusCrvManip': '',
                                           'roundRadiusManip': '',
                                           'samplerInfo': '',
                                           'scaleConstraint': '',
                                           'scaleLimitsManip': '',
                                           'scaleManip': '',
                                           'scalePointManip': '',
                                           'scaleUVManip2D': '',
                                           'scalingBoxManip': '',
                                           'screenAlignedCircleManip': '',
                                           'script': '',
                                           'scriptManip': '',
                                           'sculpt': '',
                                           'sectionManip': '',
                                           'selectionItem': '',
                                           'selectionList': '',
                                           'selectionListData': '',
                                           'selectionListOperator': '',
                                           'set': '',
                                           'setGroupComponent': '',
                                           'setRange': '',
                                           'sfRevolveManip': '',
                                           'shaderGlow': '',
                                           'shaderList': '',
                                           'shadingEngine': '',
                                           'shadingMap': '',
                                           'shape': '',
                                           'shapeEditorManager': '',
                                           'shapeFragment': '',
                                           'shrinkWrapFilter': '',
                                           'simpleVolumeShader': '',
                                           'singleIndexedComponent': '',
                                           'singleShadingSwitch': '',
                                           'sketchPlane': '',
                                           'skin': '',
                                           'skinBinding': '',
                                           'skinClusterFilter': '',
                                           'skinShader': '',
                                           'sl60': '',
                                           'smear': '',
                                           'smoothCurve': '',
                                           'smoothTangentSrf': '',
                                           'snapUVManip2D': '',
                                           'snapshot': '',
                                           'snapshotPath': '',
                                           'snapshotShape': '',
                                           'snow': '',
                                           'softMod': '',
                                           'softModFilter': '',
                                           'softModManip': '',
                                           'solidFractal': '',
                                           'sphere': '',
                                           'sphereData': '',
                                           'sphericalProjectionManip': '',
                                           'splineSolver': '',
                                           'spotCylinderManip': '',
                                           'spotLight': '',
                                           'spotManip': '',
                                           'spring': '',
                                           'sprite': '',
                                           'squareSrf': '',
                                           'squareSrfManip': '',
                                           'stateManip': '',
                                           'stencil': '',
                                           'stereoCameraMaster': 'Master node for a stereo camera rig.',
                                           'stitchAsNurbsShell': '',
                                           'stitchSrf': '',
                                           'stitchSrfManip': '',
                                           'storyBoard': '',
                                           'stringArrayData': '',
                                           'stringData': '',
                                           'stringShadingSwitch': '',
                                           'stroke': '',
                                           'strokeGlobals': '',
                                           'stucco': '',
                                           'studioClearCoat': '',
                                           'styleCurve': '',
                                           'subCurve': '',
                                           'subSurface': '',
                                           'subVertexComponent': '',
                                           'subdAddTopology': '',
                                           'subdAutoProj': '',
                                           'subdBlindData': '',
                                           'subdBoolean': '',
                                           'subdCleanTopology': '',
                                           'subdCloseBorder': '',
                                           'subdDelFace': '',
                                           'subdExtrudeFace': '',
                                           'subdHierBlind': '',
                                           'subdLayoutUV': '',
                                           'subdMapCut': '',
                                           'subdMapSewMove': '',
                                           'subdMappingManip': '',
                                           'subdMergeVert': '',
                                           'subdModifier': '',
                                           'subdModifyEdge': '',
                                           'subdMoveEdge': '',
                                           'subdMoveFace': '',
                                           'subdMoveVertex': '',
                                           'subdPlanProj': '',
                                           'subdProjectionManip': '',
                                           'subdSplitFace': '',
                                           'subdSubdivideFace': '',
                                           'subdTweak': '',
                                           'subdTweakUV': '',
                                           'subdiv': '',
                                           'subdivCVComponent': '',
                                           'subdivCollapse': '',
                                           'subdivCompId': '',
                                           'subdivData': '',
                                           'subdivEdgeComponent': '',
                                           'subdivFaceComponent': '',
                                           'subdivGeom': '',
                                           'subdivMapComponent': '',
                                           'subdivReverseFaces': '',
                                           'subdivSurfaceVarGroup': '',
                                           'subdivToNurbs': '',
                                           'subdivToPoly': '',
                                           'summaryObject': '',
                                           'super': '',
                                           'surface': '',
                                           'surfaceCVComponent': '',
                                           'surfaceEPComponent': '',
                                           'surfaceEdManip': '',
                                           'surfaceFaceComponent': '',
                                           'surfaceInfo': '',
                                           'surfaceKnotComponent': '',
                                           'surfaceLuminance': '',
                                           'surfaceRangeComponent': '',
                                           'surfaceShader': '',
                                           'surfaceVarGroup': '',
                                           'symmetryConstraint': '',
                                           'symmetryLocator': '',
                                           'symmetryMapCurve': '',
                                           'symmetryMapVector': '',
                                           'tangentConstraint': '',
                                           'tension': '',
                                           'texLattice': '',
                                           'texLatticeDeformManip': '',
                                           'texSmoothManip': '',
                                           'texSmudgeUVManip': '',
                                           'textButtonManip': '',
                                           'textCurves': '',
                                           'textManip': '',
                                           'texture2d': '',
                                           'texture3d': '',
                                           'textureBakeSet': '',
                                           'textureDeformer': '',
                                           'textureDeformerHandle': '',
                                           'textureEnv': '',
                                           'textureList': '',
                                           'textureManip3D': '',
                                           'threadedDevice': '',
                                           'threePointArcManip': '',
                                           'time': '',
                                           'timeAttribute': '',
                                           'timeEditor': '',
                                           'timeEditorAnimSource': '',
                                           'timeEditorClip': '',
                                           'timeEditorClipBase': '',
                                           'timeEditorClipEvaluator': '',
                                           'timeEditorInterpolator': '',
                                           'timeEditorTracks': '',
                                           'timeFunction': '',
                                           'timeToUnitConversion': '',
                                           'timeWarp': '',
                                           'toggleManip': '',
                                           'toggleOnLineManip': '',
                                           'toolContext': 'Tool context.',
                                           'toonLineAttributes': '',
                                           'torus': '',
                                           'towPointManip': '',
                                           'towPointOnCurveManip': '',
                                           'towPointOnSurfaceManip': '',
                                           'trackInfoManager': '',
                                           'transferAttributes': '',
                                           'transform': '',
                                           'transformBoxManip': '',
                                           'transformGeometry': '',
                                           'translateBoxManip': '',
                                           'translateLimitsManip': '',
                                           'translateManip': '',
                                           'translateManip2D': '',
                                           'translateUVManip': '',
                                           'translateUVManip2D': '',
                                           'triadManip': '',
                                           'trim': '',
                                           'trimLocator': '',
                                           'trimManip': '',
                                           'trimWithBoundaries': '',
                                           'triplanarProjectionManip': '',
                                           'tripleIndexedComponent': '',
                                           'tripleShadingSwitch': '',
                                           'trsInsertManip': '',
                                           'trsManip': '',
                                           'trsTransManip': '',
                                           'trsXformManip': '',
                                           'turbulence': '',
                                           'tweak': '',
                                           'twoPointArcManip': '',
                                           'txSl': '',
                                           'typedAttribute': '',
                                           'uint64SingleIndexedComponent': '',
                                           'underWorld': '',
                                           'uniform': '',
                                           'unitAttribute': '',
                                           'unitConversion': '',
                                           'unitToTimeConversion': '',
                                           'unknown': '',
                                           'unknownDag': '',
                                           'unknownTransform': '',
                                           'untrim': '',
                                           'unused1': '',
                                           'unused2': '',
                                           'unused3': '',
                                           'unused4': '',
                                           'unused5': '',
                                           'unused6': '',
                                           'useBackground': '',
                                           'uvChooser': '',
                                           'vectorArrayData': '',
                                           'vectorProduct': '',
                                           'vertexBakeSet': '',
                                           'vertexWeightSet': '',
                                           'viewColorManager': '',
                                           'viewManip': '',
                                           'volumeAxis': '',
                                           'volumeBindManip': '',
                                           'volumeFog': '',
                                           'volumeLight': '',
                                           'volumeNoise': '',
                                           'volumeShader': '',
                                           'vortex': '',
                                           'water': '',
                                           'weightGeometryFilt': '',
                                           'wire': '',
                                           'wood': '',
                                           'world': '',
                                           'wrapFilter': '',
                                           'writeToColorBuffer': '',
                                           'writeToDepthBuffer': '',
                                           'writeToFrameBuffer': '',
                                           'writeToLabelBuffer': '',
                                           'writeToVectorBuffer': '',
                                           'xformManip': '',
                                           'xsectionSubdivEdit': ''},
                             'values': "Enum('Type', [('kInvalid', 0), ('kBase', 1), ('kNamedObject', 2), ('kModel', 3), ('kDependencyNode', 4), ('kAddDoubleLinear', 5), ('kAffect', 6), ('kAnimCurve', 7), ('kAnimCurveTimeToAngular', 8), ('kAnimCurveTimeToDistance', 9), ('kAnimCurveTimeToTime', 10), ('kAnimCurveTimeToUnitless', 11), ('kAnimCurveUnitlessToAngular', 12), ('kAnimCurveUnitlessToDistance', 13), ('kAnimCurveUnitlessToTime', 14), ('kAnimCurveUnitlessToUnitless', 15), ('kResultCurve', 16), ('kResultCurveTimeToAngular', 17), ('kResultCurveTimeToDistance', 18), ('kResultCurveTimeToTime', 19), ('kResultCurveTimeToUnitless', 20), ('kAngleBetween', 21), ('kAudio', 22), ('kBackground', 23), ('kColorBackground', 24), ('kFileBackground', 25), ('kRampBackground', 26), ('kBlend', 27), ('kBlendTwoAttr', 28), ('kBlendWeighted', 29), ('kBlendDevice', 30), ('kBlendColors', 31), ('kBump', 32), ('kBump3d', 33), ('kCameraView', 34), ('kChainToSpline', 35), ('kChoice', 36), ('kCondition', 37), ('kContrast', 38), ('kClampColor', 39), ('kCreate', 40), ('kAlignCurve', 41), ('kAlignSurface', 42), ('kAttachCurve', 43), ('kAttachSurface', 44), ('kAvgCurves', 45), ('kAvgSurfacePoints', 46), ('kAvgNurbsSurfacePoints', 47), ('kBevel', 48), ('kBirailSrf', 49), ('kDPbirailSrf', 50), ('kMPbirailSrf', 51), ('kSPbirailSrf', 52), ('kBoundary', 53), ('kCircle', 54), ('kCloseCurve', 55), ('kClosestPointOnSurface', 56), ('kCloseSurface', 57), ('kCurveFromSurface', 58), ('kCurveFromSurfaceBnd', 59), ('kCurveFromSurfaceCoS', 60), ('kCurveFromSurfaceIso', 61), ('kCurveInfo', 62), ('kDetachCurve', 63), ('kDetachSurface', 64), ('kExtendCurve', 65), ('kExtendSurface', 66), ('kExtrude', 67), ('kFFblendSrf', 68), ('kFFfilletSrf', 69), ('kFilletCurve', 70), ('kFitBspline', 71), ('kFlow', 72), ('kHardenPointCurve', 73), ('kIllustratorCurve', 74), ('kInsertKnotCrv', 75), ('kInsertKnotSrf', 76), ('kIntersectSurface', 77), ('kNurbsTesselate', 78), ('kNurbsPlane', 79), ('kNurbsCube', 80), ('kOffsetCos', 81), ('kOffsetCurve', 82), ('kPlanarTrimSrf', 83), ('kPointOnCurveInfo', 84), ('kPointOnSurfaceInfo', 85), ('kPrimitive', 86), ('kProjectCurve', 87), ('kProjectTangent', 88), ('kRBFsurface', 89), ('kRebuildCurve', 90), ('kRebuildSurface', 91), ('kReverseCurve', 92), ('kReverseSurface', 93), ('kRevolve', 94), ('kRevolvedPrimitive', 95), ('kCone', 96), ('kRenderCone', 97), ('kCylinder', 98), ('kSphere', 99), ('kSkin', 100), ('kStitchSrf', 101), ('kSubCurve', 102), ('kSurfaceInfo', 103), ('kTextCurves', 104), ('kTrim', 105), ('kUntrim', 106), ('kDagNode', 107), ('kProxy', 108), ('kUnderWorld', 109), ('kTransform', 110), ('kAimConstraint', 111), ('kLookAt', 112), ('kGeometryConstraint', 113), ('kGeometryVarGroup', 114), ('kAnyGeometryVarGroup', 115), ('kCurveVarGroup', 116), ('kMeshVarGroup', 117), ('kSurfaceVarGroup', 118), ('kIkEffector', 119), ('kIkHandle', 120), ('kJoint', 121), ('kManipulator3D', 122), ('kArrowManip', 123), ('kAxesActionManip', 124), ('kBallProjectionManip', 125), ('kCircleManip', 126), ('kScreenAlignedCircleManip', 127), ('kCircleSweepManip', 128), ('kConcentricProjectionManip', 129), ('kCubicProjectionManip', 130), ('kCylindricalProjectionManip', 131), ('kDiscManip', 132), ('kFreePointManip', 133), ('kCenterManip', 134), ('kLimitManip', 135), ('kEnableManip', 136), ('kFreePointTriadManip', 137), ('kPropMoveTriadManip', 138), ('kTowPointManip', 139), ('kPolyCreateToolManip', 140), ('kPolySplitToolManip', 141), ('kGeometryOnLineManip', 142), ('kCameraPlaneManip', 143), ('kToggleOnLineManip', 144), ('kStateManip', 145), ('kIsoparmManip', 146), ('kLineManip', 147), ('kManipContainer', 148), ('kAverageCurveManip', 149), ('kBarnDoorManip', 150), ('kBevelManip', 151), ('kBlendManip', 152), ('kButtonManip', 153), ('kCameraManip', 154), ('kCoiManip', 155), ('kCpManip', 156), ('kCreateCVManip', 157), ('kCreateEPManip', 158), ('kCurveEdManip', 159), ('kCurveSegmentManip', 160), ('kDirectionManip', 161), ('kDofManip', 162), ('kDropoffManip', 163), ('kExtendCurveDistanceManip', 164), ('kExtrudeManip', 165), ('kIkSplineManip', 166), ('kIkRPManip', 167), ('kJointClusterManip', 168), ('kLightManip', 169), ('kMotionPathManip', 170), ('kOffsetCosManip', 171), ('kOffsetCurveManip', 172), ('kProjectionManip', 173), ('kPolyProjectionManip', 174), ('kProjectionUVManip', 175), ('kProjectionMultiManip', 176), ('kProjectTangentManip', 177), ('kPropModManip', 178), ('kQuadPtOnLineManip', 179), ('kRbfSrfManip', 180), ('kReverseCurveManip', 181), ('kReverseCrvManip', 182), ('kReverseSurfaceManip', 183), ('kRevolveManip', 184), ('kRevolvedPrimitiveManip', 185), ('kSpotManip', 186), ('kSpotCylinderManip', 187), ('kTriplanarProjectionManip', 188), ('kTrsManip', 189), ('kDblTrsManip', 190), ('kPivotManip2D', 191), ('kManip2DContainer', 192), ('kPolyMoveUVManip', 193), ('kPolyMappingManip', 194), ('kPolyModifierManip', 195), ('kPolyMoveVertexManip', 196), ('kPolyVertexNormalManip', 197), ('kTexSmudgeUVManip', 198), ('kTexLatticeDeformManip', 199), ('kTexLattice', 200), ('kTexSmoothManip', 201), ('kTrsTransManip', 202), ('kTrsInsertManip', 203), ('kTrsXformManip', 204), ('kManipulator2D', 205), ('kTranslateManip2D', 206), ('kPlanarProjectionManip', 207), ('kPointOnCurveManip', 208), ('kTowPointOnCurveManip', 209), ('kMarkerManip', 210), ('kPointOnLineManip', 211), ('kPointOnSurfaceManip', 212), ('kTranslateUVManip', 213), ('kRotateBoxManip', 214), ('kRotateManip', 215), ('kHandleRotateManip', 216), ('kRotateLimitsManip', 217), ('kScaleLimitsManip', 218), ('kScaleManip', 219), ('kScalingBoxManip', 220), ('kScriptManip', 221), ('kSphericalProjectionManip', 222), ('kTextureManip3D', 223), ('kToggleManip', 224), ('kTranslateBoxManip', 225), ('kTranslateLimitsManip', 226), ('kTranslateManip', 227), ('kTrimManip', 228), ('kJointTranslateManip', 229), ('kManipulator', 230), ('kCirclePointManip', 231), ('kDimensionManip', 232), ('kFixedLineManip', 233), ('kLightProjectionGeometry', 234), ('kLineArrowManip', 235), ('kPointManip', 236), ('kTriadManip', 237), ('kNormalConstraint', 238), ('kOrientConstraint', 239), ('kPointConstraint', 240), ('kSymmetryConstraint', 241), ('kParentConstraint', 242), ('kPoleVectorConstraint', 243), ('kScaleConstraint', 244), ('kTangentConstraint', 245), ('kUnknownTransform', 246), ('kWorld', 247), ('kShape', 248), ('kBaseLattice', 249), ('kCamera', 250), ('kCluster', 251), ('kSoftMod', 252), ('kCollision', 253), ('kDummy', 254), ('kEmitter', 255), ('kField', 256), ('kAir', 257), ('kDrag', 258), ('kGravity', 259), ('kNewton', 260), ('kRadial', 261), ('kTurbulence', 262), ('kUniform', 263), ('kVortex', 264), ('kGeometric', 265), ('kCurve', 266), ('kNurbsCurve', 267), ('kNurbsCurveGeom', 268), ('kDimension', 269), ('kAngle', 270), ('kAnnotation', 271), ('kDistance', 272), ('kArcLength', 273), ('kRadius', 274), ('kParamDimension', 275), ('kDirectedDisc', 276), ('kRenderRect', 277), ('kEnvFogShape', 278), ('kLattice', 279), ('kLatticeGeom', 280), ('kLocator', 281), ('kDropoffLocator', 282), ('kMarker', 283), ('kOrientationMarker', 284), ('kPositionMarker', 285), ('kOrientationLocator', 286), ('kTrimLocator', 287), ('kPlane', 288), ('kSketchPlane', 289), ('kGroundPlane', 290), ('kOrthoGrid', 291), ('kSprite', 292), ('kSurface', 293), ('kNurbsSurface', 294), ('kNurbsSurfaceGeom', 295), ('kMesh', 296), ('kMeshGeom', 297), ('kRenderSphere', 298), ('kFlexor', 299), ('kClusterFlexor', 300), ('kGuideLine', 301), ('kLight', 302), ('kAmbientLight', 303), ('kNonAmbientLight', 304), ('kAreaLight', 305), ('kLinearLight', 306), ('kNonExtendedLight', 307), ('kDirectionalLight', 308), ('kPointLight', 309), ('kSpotLight', 310), ('kParticle', 311), ('kPolyToolFeedbackShape', 312), ('kRigidConstraint', 313), ('kRigid', 314), ('kSpring', 315), ('kUnknownDag', 316), ('kDefaultLightList', 317), ('kDeleteComponent', 318), ('kDispatchCompute', 319), ('kShadingEngine', 320), ('kDisplacementShader', 321), ('kDistanceBetween', 322), ('kDOF', 323), ('kDummyConnectable', 324), ('kDynamicsController', 325), ('kGeoConnectable', 326), ('kExpression', 327), ('kExtract', 328), ('kFilter', 329), ('kFilterClosestSample', 330), ('kFilterEuler', 331), ('kFilterSimplify', 332), ('kGammaCorrect', 333), ('kGeometryFilt', 334), ('kBendLattice', 335), ('kBlendShape', 336), ('kCombinationShape', 337), ('kBulgeLattice', 338), ('kFFD', 339), ('kFfdDualBase', 340), ('kRigidDeform', 341), ('kSculpt', 342), ('kTextureDeformer', 343), ('kTextureDeformerHandle', 344), ('kTweak', 345), ('kWeightGeometryFilt', 346), ('kClusterFilter', 347), ('kSoftModFilter', 348), ('kJointCluster', 349), ('kDeltaMush', 350), ('kTension', 351), ('kProxWrap', 352), ('kWire', 353), ('kGroupId', 354), ('kGroupParts', 355), ('kGuide', 356), ('kHsvToRgb', 357), ('kHyperGraphInfo', 358), ('kHyperLayout', 359), ('kHyperView', 360), ('kIkSolver', 361), ('kMCsolver', 362), ('kPASolver', 363), ('kSCsolver', 364), ('kRPsolver', 365), ('kSplineSolver', 366), ('kIkSystem', 367), ('kImagePlane', 368), ('kLambert', 369), ('kReflect', 370), ('kBlinn', 371), ('kPhong', 372), ('kPhongExplorer', 373), ('kLayeredShader', 374), ('kLightInfo', 375), ('kLeastSquares', 376), ('kLightFogMaterial', 377), ('kEnvFogMaterial', 378), ('kLightList', 379), ('kLightSource', 380), ('kLuminance', 381), ('kMakeGroup', 382), ('kMaterial', 383), ('kDiffuseMaterial', 384), ('kLambertMaterial', 385), ('kBlinnMaterial', 386), ('kPhongMaterial', 387), ('kLightSourceMaterial', 388), ('kMaterialInfo', 389), ('kMatrixAdd', 390), ('kMatrixHold', 391), ('kMatrixMult', 392), ('kMatrixPass', 393), ('kMatrixWtAdd', 394), ('kMidModifier', 395), ('kMidModifierWithMatrix', 396), ('kPolyBevel', 397), ('kPolyTweak', 398), ('kPolyAppend', 399), ('kPolyChipOff', 400), ('kPolyCloseBorder', 401), ('kPolyCollapseEdge', 402), ('kPolyCollapseF', 403), ('kPolyCylProj', 404), ('kPolyDelEdge', 405), ('kPolyDelFacet', 406), ('kPolyDelVertex', 407), ('kPolyExtrudeFacet', 408), ('kPolyMapCut', 409), ('kPolyMapDel', 410), ('kPolyMapSew', 411), ('kPolyMergeEdge', 412), ('kPolyMergeFacet', 413), ('kPolyMoveEdge', 414), ('kPolyMoveFacet', 415), ('kPolyMoveFacetUV', 416), ('kPolyMoveUV', 417), ('kPolyMoveVertex', 418), ('kPolyMoveVertexUV', 419), ('kPolyNormal', 420), ('kPolyPlanProj', 421), ('kPolyProj', 422), ('kPolyQuad', 423), ('kPolySmooth', 424), ('kPolySoftEdge', 425), ('kPolySphProj', 426), ('kPolySplit', 427), ('kPolySubdEdge', 428), ('kPolySubdFacet', 429), ('kPolyTriangulate', 430), ('kPolyCreator', 431), ('kPolyPrimitive', 432), ('kPolyCone', 433), ('kPolyCube', 434), ('kPolyCylinder', 435), ('kPolyMesh', 436), ('kPolySphere', 437), ('kPolyTorus', 438), ('kPolyCreateFacet', 439), ('kPolyUnite', 440), ('kMotionPath', 441), ('kPluginMotionPathNode', 442), ('kMultilisterLight', 443), ('kMultiplyDivide', 444), ('kOldGeometryConstraint', 445), ('kOpticalFX', 446), ('kParticleAgeMapper', 447), ('kParticleCloud', 448), ('kParticleColorMapper', 449), ('kParticleIncandecenceMapper', 450), ('kParticleTransparencyMapper', 451), ('kPartition', 452), ('kPlace2dTexture', 453), ('kPlace3dTexture', 454), ('kPluginDependNode', 455), ('kPluginLocatorNode', 456), ('kPlusMinusAverage', 457), ('kPointMatrixMult', 458), ('kPolySeparate', 459), ('kPostProcessList', 460), ('kProjection', 461), ('kRecord', 462), ('kRenderUtilityList', 463), ('kReverse', 464), ('kRgbToHsv', 465), ('kRigidSolver', 466), ('kSet', 467), ('kTextureBakeSet', 468), ('kVertexBakeSet', 469), ('kSetRange', 470), ('kShaderGlow', 471), ('kShaderList', 472), ('kShadingMap', 473), ('kSamplerInfo', 474), ('kShapeFragment', 475), ('kSimpleVolumeShader', 476), ('kSl60', 477), ('kSnapshot', 478), ('kStoryBoard', 479), ('kSummaryObject', 480), ('kSuper', 481), ('kControl', 482), ('kSurfaceLuminance', 483), ('kSurfaceShader', 484), ('kTextureList', 485), ('kTextureEnv', 486), ('kEnvBall', 487), ('kEnvCube', 488), ('kEnvChrome', 489), ('kEnvSky', 490), ('kEnvSphere', 491), ('kTexture2d', 492), ('kBulge', 493), ('kChecker', 494), ('kCloth', 495), ('kFileTexture', 496), ('kFractal', 497), ('kGrid', 498), ('kMountain', 499), ('kRamp', 500), ('kStencil', 501), ('kWater', 502), ('kTexture3d', 503), ('kBrownian', 504), ('kCloud', 505), ('kCrater', 506), ('kGranite', 507), ('kLeather', 508), ('kMarble', 509), ('kRock', 510), ('kSnow', 511), ('kSolidFractal', 512), ('kStucco', 513), ('kTxSl', 514), ('kWood', 515), ('kTime', 516), ('kTimeToUnitConversion', 517), ('kRenderSetup', 518), ('kRenderGlobals', 519), ('kRenderGlobalsList', 520), ('kRenderQuality', 521), ('kResolution', 522), ('kHardwareRenderGlobals', 523), ('kArrayMapper', 524), ('kUnitConversion', 525), ('kUnitToTimeConversion', 526), ('kUseBackground', 527), ('kUnknown', 528), ('kVectorProduct', 529), ('kVolumeShader', 530), ('kComponent', 531), ('kCurveCVComponent', 532), ('kCurveEPComponent', 533), ('kCurveKnotComponent', 534), ('kCurveParamComponent', 535), ('kIsoparmComponent', 536), ('kPivotComponent', 537), ('kSurfaceCVComponent', 538), ('kSurfaceEPComponent', 539), ('kSurfaceKnotComponent', 540), ('kEdgeComponent', 541), ('kLatticeComponent', 542), ('kSurfaceRangeComponent', 543), ('kDecayRegionCapComponent', 544), ('kDecayRegionComponent', 545), ('kMeshComponent', 546), ('kMeshEdgeComponent', 547), ('kMeshPolygonComponent', 548), ('kMeshFrEdgeComponent', 549), ('kMeshVertComponent', 550), ('kMeshFaceVertComponent', 551), ('kOrientationComponent', 552), ('kSubVertexComponent', 553), ('kMultiSubVertexComponent', 554), ('kSetGroupComponent', 555), ('kDynParticleSetComponent', 556), ('kSelectionItem', 557), ('kDagSelectionItem', 558), ('kNonDagSelectionItem', 559), ('kItemList', 560), ('kAttribute', 561), ('kNumericAttribute', 562), ('kDoubleAngleAttribute', 563), ('kFloatAngleAttribute', 564), ('kDoubleLinearAttribute', 565), ('kFloatLinearAttribute', 566), ('kTimeAttribute', 567), ('kEnumAttribute', 568), ('kUnitAttribute', 569), ('kTypedAttribute', 570), ('kCompoundAttribute', 571), ('kGenericAttribute', 572), ('kLightDataAttribute', 573), ('kMatrixAttribute', 574), ('kFloatMatrixAttribute', 575), ('kMessageAttribute', 576), ('kPlugin', 577), ('kData', 578), ('kComponentListData', 579), ('kDoubleArrayData', 580), ('kIntArrayData', 581), ('kLatticeData', 582), ('kMatrixData', 583), ('kMeshData', 584), ('kNurbsSurfaceData', 585), ('kNurbsCurveData', 586), ('kNumericData', 587), ('kData2Double', 588), ('kData2Float', 589), ('kData2Long', 590), ('kData2Int', 590), ('kData2Short', 591), ('kData3Double', 592), ('kData3Float', 593), ('kData3Int', 594), ('kData3Long', 594), ('kData3Short', 595), ('kPluginData', 596), ('kPointArrayData', 597), ('kMatrixArrayData', 598), ('kSphereData', 599), ('kStringData', 600), ('kStringArrayData', 601), ('kVectorArrayData', 602), ('kSelectionList', 603), ('kTransformGeometry', 604), ('kCommEdgePtManip', 605), ('kCommEdgeOperManip', 606), ('kCommEdgeSegmentManip', 607), ('kCommCornerManip', 608), ('kCommCornerOperManip', 609), ('kPluginDeformerNode', 610), ('kTorus', 611), ('kPolyBoolOp', 612), ('kSingleShadingSwitch', 613), ('kDoubleShadingSwitch', 614), ('kTripleShadingSwitch', 615), ('kNurbsSquare', 616), ('kAnisotropy', 617), ('kNonLinear', 618), ('kDeformFunc', 619), ('kDeformBend', 620), ('kDeformTwist', 621), ('kDeformSquash', 622), ('kDeformFlare', 623), ('kDeformSine', 624), ('kDeformWave', 625), ('kDeformBendManip', 626), ('kDeformTwistManip', 627), ('kDeformSquashManip', 628), ('kDeformFlareManip', 629), ('kDeformSineManip', 630), ('kDeformWaveManip', 631), ('kSoftModManip', 632), ('kDistanceManip', 633), ('kScript', 634), ('kCurveFromMeshEdge', 635), ('kCurveCurveIntersect', 636), ('kNurbsCircular3PtArc', 637), ('kNurbsCircular2PtArc', 638), ('kOffsetSurface', 639), ('kRoundConstantRadius', 640), ('kRoundRadiusManip', 641), ('kRoundRadiusCrvManip', 642), ('kRoundConstantRadiusManip', 643), ('kThreePointArcManip', 644), ('kTwoPointArcManip', 645), ('kTextButtonManip', 646), ('kOffsetSurfaceManip', 647), ('kImageData', 648), ('kImageLoad', 649), ('kImageSave', 650), ('kImageNetSrc', 651), ('kImageNetDest', 652), ('kImageRender', 653), ('kImageAdd', 654), ('kImageDiff', 655), ('kImageMultiply', 656), ('kImageOver', 657), ('kImageUnder', 658), ('kImageColorCorrect', 659), ('kImageBlur', 660), ('kImageFilter', 661), ('kImageDepth', 662), ('kImageDisplay', 663), ('kImageView', 664), ('kImageMotionBlur', 665), ('kViewColorManager', 666), ('kMatrixFloatData', 667), ('kSkinShader', 668), ('kComponentManip', 669), ('kSelectionListData', 670), ('kObjectFilter', 671), ('kObjectMultiFilter', 672), ('kObjectNameFilter', 673), ('kObjectTypeFilter', 674), ('kObjectAttrFilter', 675), ('kObjectRenderFilter', 676), ('kObjectScriptFilter', 677), ('kSelectionListOperator', 678), ('kSubdiv', 679), ('kPolyToSubdiv', 680), ('kSkinClusterFilter', 681), ('kCharacter', 683), ('kCharacterOffset', 684), ('kDagPose', 685), ('kStitchAsNurbsShell', 686), ('kExplodeNurbsShell', 687), ('kNurbsBoolean', 688), ('kStitchSrfManip', 689), ('kForceUpdateManip', 690), ('kPluginManipContainer', 691), ('kPolySewEdge', 692), ('kPolyMergeVert', 693), ('kPolySmoothFacet', 694), ('kSmoothCurve', 695), ('kGlobalStitch', 696), ('kSubdivCVComponent', 697), ('kSubdivEdgeComponent', 698), ('kSubdivFaceComponent', 699), ('kUVManip2D', 700), ('kTranslateUVManip2D', 701), ('kRotateUVManip2D', 702), ('kScaleUVManip2D', 703), ('kPolyTweakUV', 704), ('kMoveUVShellManip2D', 705), ('kPluginShape', 706), ('kGeometryData', 707), ('kSingleIndexedComponent', 708), ('kDoubleIndexedComponent', 709), ('kTripleIndexedComponent', 710), ('kExtendSurfaceDistanceManip', 711), ('kSquareSrf', 712), ('kSquareSrfManip', 713), ('kSubdivToPoly', 714), ('kDynBase', 715), ('kDynEmitterManip', 716), ('kDynFieldsManip', 717), ('kDynBaseFieldManip', 718), ('kDynAirManip', 719), ('kDynNewtonManip', 720), ('kDynTurbulenceManip', 721), ('kDynSpreadManip', 722), ('kDynAttenuationManip', 723), ('kDynArrayAttrsData', 724), ('kPluginFieldNode', 725), ('kPluginEmitterNode', 726), ('kPluginSpringNode', 727), ('kDisplayLayer', 728), ('kDisplayLayerManager', 729), ('kPolyColorPerVertex', 730), ('kCreateColorSet', 731), ('kDeleteColorSet', 732), ('kCopyColorSet', 733), ('kBlendColorSet', 734), ('kPolyColorMod', 735), ('kPolyColorDel', 736), ('kCharacterMappingData', 737), ('kDynSweptGeometryData', 738), ('kWrapFilter', 739), ('kMeshVtxFaceComponent', 740), ('kBinaryData', 741), ('kAttribute2Double', 742), ('kAttribute2Float', 743), ('kAttribute2Short', 744), ('kAttribute2Long', 745), ('kAttribute2Int', 745), ('kAttribute3Double', 746), ('kAttribute3Float', 747), ('kAttribute3Short', 748), ('kAttribute3Int', 749), ('kAttribute3Long', 749), ('kReference', 750), ('kBlindData', 751), ('kBlindDataTemplate', 752), ('kPolyBlindData', 753), ('kPolyNormalPerVertex', 754), ('kNurbsToSubdiv', 755), ('kPluginIkSolver', 756), ('kInstancer', 757), ('kMoveVertexManip', 758), ('kStroke', 759), ('kBrush', 760), ('kStrokeGlobals', 761), ('kPluginGeometryData', 762), ('kLightLink', 763), ('kDynGlobals', 764), ('kPolyReduce', 765), ('kLodThresholds', 766), ('kChooser', 767), ('kLodGroup', 768), ('kMultDoubleLinear', 769), ('kFourByFourMatrix', 770), ('kTowPointOnSurfaceManip', 771), ('kSurfaceEdManip', 772), ('kSurfaceFaceComponent', 773), ('kClipScheduler', 774), ('kClipLibrary', 775), ('kSubSurface', 776), ('kSmoothTangentSrf', 777), ('kRenderPass', 778), ('kRenderPassSet', 779), ('kRenderLayer', 780), ('kRenderLayerManager', 781), ('kPassContributionMap', 782), ('kPrecompExport', 783), ('kRenderTarget', 784), ('kRenderedImageSource', 785), ('kImageSource', 786), ('kPolyFlipEdge', 787), ('kPolyExtrudeEdge', 788), ('kAnimBlend', 789), ('kAnimBlendInOut', 790), ('kPolyAppendVertex', 791), ('kUvChooser', 792), ('kSubdivCompId', 793), ('kVolumeAxis', 794), ('kDeleteUVSet', 795), ('kSubdHierBlind', 796), ('kSubdBlindData', 797), ('kCharacterMap', 798), ('kLayeredTexture', 799), ('kSubdivCollapse', 800), ('kParticleSamplerInfo', 801), ('kCopyUVSet', 802), ('kCreateUVSet', 803), ('kClip', 804), ('kPolySplitVert', 805), ('kSubdivData', 806), ('kSubdivGeom', 807), ('kUInt64ArrayData', 808), ('kInt64ArrayData', 809), ('kPolySplitEdge', 810), ('kSubdivReverseFaces', 811), ('kMeshMapComponent', 812), ('kSectionManip', 813), ('kXsectionSubdivEdit', 814), ('kSubdivToNurbs', 815), ('kEditCurve', 816), ('kEditCurveManip', 817), ('kCrossSectionManager', 818), ('kCreateSectionManip', 819), ('kCrossSectionEditManip', 820), ('kDropOffFunction', 821), ('kSubdBoolean', 822), ('kSubdModifyEdge', 823), ('kModifyEdgeCrvManip', 824), ('kModifyEdgeManip', 825), ('kScalePointManip', 826), ('kTransformBoxManip', 827), ('kSymmetryLocator', 828), ('kSymmetryMapVector', 829), ('kSymmetryMapCurve', 830), ('kCurveFromSubdivEdge', 831), ('kCreateBPManip', 832), ('kModifyEdgeBaseManip', 833), ('kSubdExtrudeFace', 834), ('kSubdivSurfaceVarGroup', 835), ('kSfRevolveManip', 836), ('kCurveFromSubdivFace', 837), ('kUnused1', 838), ('kUnused2', 839), ('kUnused3', 840), ('kUnused4', 841), ('kUnused5', 842), ('kUnused6', 843), ('kPolyTransfer', 844), ('kPolyAverageVertex', 845), ('kPolyAutoProj', 846), ('kPolyLayoutUV', 847), ('kPolyMapSewMove', 848), ('kSubdModifier', 849), ('kSubdMoveVertex', 850), ('kSubdMoveEdge', 851), ('kSubdMoveFace', 852), ('kSubdDelFace', 853), ('kSnapshotShape', 854), ('kSubdivMapComponent', 855), ('kJiggleDeformer', 856), ('kGlobalCacheControls', 857), ('kDiskCache', 858), ('kSubdCloseBorder', 859), ('kSubdMergeVert', 860), ('kBoxData', 861), ('kBox', 862), ('kRenderBox', 863), ('kSubdSplitFace', 864), ('kVolumeFog', 865), ('kSubdTweakUV', 866), ('kSubdMapCut', 867), ('kSubdLayoutUV', 868), ('kSubdMapSewMove', 869), ('kOcean', 870), ('kVolumeNoise', 871), ('kSubdAutoProj', 872), ('kSubdSubdivideFace', 873), ('kNoise', 874), ('kAttribute4Double', 875), ('kData4Double', 876), ('kSubdPlanProj', 877), ('kSubdTweak', 878), ('kSubdProjectionManip', 879), ('kSubdMappingManip', 880), ('kHardwareReflectionMap', 881), ('kPolyNormalizeUV', 882), ('kPolyFlipUV', 883), ('kHwShaderNode', 884), ('kPluginHardwareShader', 885), ('kPluginHwShaderNode', 886), ('kSubdAddTopology', 887), ('kSubdCleanTopology', 888), ('kImplicitCone', 889), ('kImplicitSphere', 890), ('kRampShader', 891), ('kVolumeLight', 892), ('kOceanShader', 893), ('kBevelPlus', 894), ('kStyleCurve', 895), ('kPolyCut', 896), ('kPolyPoke', 897), ('kPolyWedgeFace', 898), ('kPolyCutManipContainer', 899), ('kPolyCutManip', 900), ('kPolyMirrorManipContainer', 901), ('kPolyPokeManip', 902), ('kFluidTexture3D', 903), ('kFluidTexture2D', 904), ('kPolyMergeUV', 905), ('kPolyStraightenUVBorder', 906), ('kAlignManip', 907), ('kPluginTransformNode', 908), ('kFluid', 909), ('kFluidGeom', 910), ('kFluidData', 911), ('kSmear', 912), ('kStringShadingSwitch', 913), ('kStudioClearCoat', 914), ('kFluidEmitter', 915), ('kHeightField', 916), ('kGeoConnector', 917), ('kSnapshotPath', 918), ('kPluginObjectSet', 919), ('kQuadShadingSwitch', 920), ('kPolyExtrudeVertex', 921), ('kPairBlend', 922), ('kTextManip', 923), ('kViewManip', 924), ('kXformManip', 925), ('kMute', 926), ('kConstraint', 927), ('kTrimWithBoundaries', 928), ('kCurveFromMeshCoM', 929), ('kFollicle', 930), ('kHairSystem', 931), ('kRemapValue', 932), ('kRemapColor', 933), ('kRemapHsv', 934), ('kHairConstraint', 935), ('kTimeFunction', 936), ('kMentalRayTexture', 937), ('kObjectBinFilter', 938), ('kPolySmoothProxy', 939), ('kPfxGeometry', 940), ('kPfxHair', 941), ('kHairTubeShader', 942), ('kPsdFileTexture', 943), ('kKeyframeDelta', 944), ('kKeyframeDeltaMove', 945), ('kKeyframeDeltaScale', 946), ('kKeyframeDeltaAddRemove', 947), ('kKeyframeDeltaBlockAddRemove', 948), ('kKeyframeDeltaInfType', 949), ('kKeyframeDeltaTangent', 950), ('kKeyframeDeltaWeighted', 951), ('kKeyframeDeltaBreakdown', 952), ('kPolyMirror', 953), ('kPolyCreaseEdge', 954), ('kPolyPinUV', 955), ('kHikEffector', 956), ('kHikIKEffector', 957), ('kHikFKJoint', 958), ('kHikSolver', 959), ('kHikHandle', 960), ('kProxyManager', 961), ('kPolyAutoProjManip', 962), ('kPolyPrism', 963), ('kPolyPyramid', 964), ('kPolySplitRing', 965), ('kPfxToon', 966), ('kToonLineAttributes', 967), ('kPolyDuplicateEdge', 968), ('kFacade', 969), ('kMaterialFacade', 970), ('kEnvFacade', 971), ('kAISEnvFacade', 972), ('kLineModifier', 973), ('kPolyArrow', 974), ('kPolyPrimitiveMisc', 975), ('kPolyPlatonicSolid', 976), ('kPolyPipe', 977), ('kHikFloorContactMarker', 978), ('kHikGroundPlane', 979), ('kPolyComponentData', 980), ('kPolyHelix', 981), ('kCacheFile', 982), ('kHistorySwitch', 983), ('kClosestPointOnMesh', 984), ('kTransferAttributes', 985), ('kDynamicConstraint', 986), ('kNComponent', 987), ('kPolyBridgeEdge', 988), ('kCacheableNode', 989), ('kNucleus', 990), ('kNBase', 991), ('kCacheBase', 992), ('kCacheBlend', 993), ('kCacheTrack', 994), ('kKeyframeRegionManip', 995), ('kCurveNormalizerAngle', 996), ('kCurveNormalizerLinear', 997), ('kHyperLayoutDG', 998), ('kPluginImagePlaneNode', 999), ('kNCloth', 1000), ('kNParticle', 1001), ('kNRigid', 1002), ('kPluginParticleAttributeMapperNode', 1003), ('kCameraSet', 1004), ('kPluginCameraSet', 1005), ('kContainer', 1006), ('kFloatVectorArrayData', 1007), ('kNObjectData', 1008), ('kNObject', 1009), ('kPluginConstraintNode', 1010), ('kAsset', 1011), ('kPolyEdgeToCurve', 1012), ('kAnimLayer', 1013), ('kBlendNodeBase', 1014), ('kBlendNodeBoolean', 1015), ('kBlendNodeDouble', 1016), ('kBlendNodeDoubleAngle', 1017), ('kBlendNodeDoubleLinear', 1018), ('kBlendNodeEnum', 1019), ('kBlendNodeFloat', 1020), ('kBlendNodeFloatAngle', 1021), ('kBlendNodeFloatLinear', 1022), ('kBlendNodeInt16', 1023), ('kBlendNodeInt32', 1024), ('kBlendNodeAdditiveScale', 1025), ('kBlendNodeAdditiveRotation', 1026), ('kPluginManipulatorNode', 1027), ('kNIdData', 1028), ('kNId', 1029), ('kFloatArrayData', 1030), ('kMembrane', 1031), ('kMergeVertsToolManip', 1032), ('kUint64SingleIndexedComponent', 1033), ('kPolyToolFeedbackManip', 1034), ('kPolySelectEditFeedbackManip', 1035), ('kWriteToFrameBuffer', 1036), ('kWriteToColorBuffer', 1037), ('kWriteToVectorBuffer', 1038), ('kWriteToDepthBuffer', 1039), ('kWriteToLabelBuffer', 1040), ('kStereoCameraMaster', 1041), ('kBlendNodeTime', 1045), ('kCreateBezierManip', 1046), ('kBezierCurve', 1047), ('kBezierCurveData', 1048), ('kNurbsCurveToBezier', 1049), ('kBezierCurveToNurbs', 1050), ('kPolySpinEdge', 1051), ('kPolyHoleFace', 1052), ('kPointOnPolyConstraint', 1053), ('kPolyConnectComponents', 1054), ('kSkinBinding', 1055), ('kVolumeBindManip', 1056), ('kVertexWeightSet', 1057), ('kNearestPointOnCurve', 1058), ('kColorProfile', 1059), ('kAdskMaterial', 1060), ('kContainerBase', 1061), ('kDagContainer', 1062), ('kPolyUVRectangle', 1063), ('kHardwareRenderingGlobals', 1064), ('kPolyProjectCurve', 1065), ('kRenderingList', 1066), ('kPolyExtrudeManip', 1067), ('kPolyExtrudeManipContainer', 1068), ('kThreadedDevice', 1069), ('kClientDevice', 1070), ('kPluginClientDevice', 1071), ('kPluginThreadedDevice', 1072), ('kTimeWarp', 1073), ('kAssembly', 1074), ('kClipGhostShape', 1075), ('kClipToGhostData', 1076), ('kMandelbrot', 1077), ('kMandelbrot3D', 1078), ('kGreasePlane', 1079), ('kGreasePlaneRenderShape', 1080), ('kGreasePencilSequence', 1081), ('kEditMetadata', 1082), ('kCreaseSet', 1083), ('kPolyEditEdgeFlow', 1084), ('kFosterParent', 1085), ('kSnapUVManip2D', 1086), ('kToolContext', 1087), ('kNLE', 1088), ('kShrinkWrapFilter', 1089), ('kEditsManager', 1090), ('kPolyBevel2', 1091), ('kPolyCBoolOp', 1092), ('kGeomBind', 1093), ('kColorMgtGlobals', 1094), ('kPolyBevel3', 1095), ('kTimeEditorClipBase', 1096), ('kTimeEditorClipEvaluator', 1097), ('kTimeEditorClip', 1098), ('kTimeEditor', 1099), ('kTimeEditorTracks', 1100), ('kTimeEditorInterpolator', 1101), ('kTimeEditorAnimSource', 1102), ('kCaddyManipBase', 1103), ('kPolyCaddyManip', 1104), ('kPolyModifierManipContainer', 1105), ('kPolyRemesh', 1106), ('kPolyContourProj', 1107), ('kContourProjectionManip', 1108), ('kNodeGraphEditorInfo', 1109), ('kNodeGraphEditorBookmarks', 1110), ('kNodeGraphEditorBookmarkInfo', 1111), ('kPluginSkinCluster', 1112), ('kPluginGeometryFilter', 1113), ('kPluginBlendShape', 1114), ('kTrackInfoManager', 1116), ('kPolyClean', 1117), ('kShapeEditorManager', 1118), ('kOceanDeformer', 1119), ('kPoseInterpolatorManager', 1120), ('kControllerTag', 1121), ('kReForm', 1122), ('kCustomEvaluatorClusterNode', 1123), ('kPolyCircularize', 1124), ('kLast', 1127)], multiKeys=True)"}},
          'methods': {},
          'pymelEnums': {'Type': "Enum('Type', [('invalid', 0), ('kInvalid', 0), ('base', 1), ('kBase', 1), ('namedObject', 2), ('kNamedObject', 2), ('model', 3), ('kModel', 3), ('dependencyNode', 4), ('kDependencyNode', 4), ('addDoubleLinear', 5), ('kAddDoubleLinear', 5), ('affect', 6), ('kAffect', 6), ('animCurve', 7), ('kAnimCurve', 7), ('animCurveTimeToAngular', 8), ('kAnimCurveTimeToAngular', 8), ('animCurveTimeToDistance', 9), ('kAnimCurveTimeToDistance', 9), ('animCurveTimeToTime', 10), ('kAnimCurveTimeToTime', 10), ('animCurveTimeToUnitless', 11), ('kAnimCurveTimeToUnitless', 11), ('animCurveUnitlessToAngular', 12), ('kAnimCurveUnitlessToAngular', 12), ('animCurveUnitlessToDistance', 13), ('kAnimCurveUnitlessToDistance', 13), ('animCurveUnitlessToTime', 14), ('kAnimCurveUnitlessToTime', 14), ('animCurveUnitlessToUnitless', 15), ('kAnimCurveUnitlessToUnitless', 15), ('resultCurve', 16), ('kResultCurve', 16), ('resultCurveTimeToAngular', 17), ('kResultCurveTimeToAngular', 17), ('resultCurveTimeToDistance', 18), ('kResultCurveTimeToDistance', 18), ('resultCurveTimeToTime', 19), ('kResultCurveTimeToTime', 19), ('resultCurveTimeToUnitless', 20), ('kResultCurveTimeToUnitless', 20), ('angleBetween', 21), ('kAngleBetween', 21), ('audio', 22), ('kAudio', 22), ('background', 23), ('kBackground', 23), ('colorBackground', 24), ('kColorBackground', 24), ('fileBackground', 25), ('kFileBackground', 25), ('rampBackground', 26), ('kRampBackground', 26), ('blend', 27), ('kBlend', 27), ('blendTwoAttr', 28), ('kBlendTwoAttr', 28), ('blendWeighted', 29), ('kBlendWeighted', 29), ('blendDevice', 30), ('kBlendDevice', 30), ('blendColors', 31), ('kBlendColors', 31), ('bump', 32), ('kBump', 32), ('bump3d', 33), ('kBump3d', 33), ('cameraView', 34), ('kCameraView', 34), ('chainToSpline', 35), ('kChainToSpline', 35), ('choice', 36), ('kChoice', 36), ('condition', 37), ('kCondition', 37), ('contrast', 38), ('kContrast', 38), ('clampColor', 39), ('kClampColor', 39), ('create', 40), ('kCreate', 40), ('alignCurve', 41), ('kAlignCurve', 41), ('alignSurface', 42), ('kAlignSurface', 42), ('attachCurve', 43), ('kAttachCurve', 43), ('attachSurface', 44), ('kAttachSurface', 44), ('avgCurves', 45), ('kAvgCurves', 45), ('avgSurfacePoints', 46), ('kAvgSurfacePoints', 46), ('avgNurbsSurfacePoints', 47), ('kAvgNurbsSurfacePoints', 47), ('bevel', 48), ('kBevel', 48), ('birailSrf', 49), ('kBirailSrf', 49), ('DPbirailSrf', 50), ('kDPbirailSrf', 50), ('MPbirailSrf', 51), ('kMPbirailSrf', 51), ('SPbirailSrf', 52), ('kSPbirailSrf', 52), ('boundary', 53), ('kBoundary', 53), ('circle', 54), ('kCircle', 54), ('closeCurve', 55), ('kCloseCurve', 55), ('closestPointOnSurface', 56), ('kClosestPointOnSurface', 56), ('closeSurface', 57), ('kCloseSurface', 57), ('curveFromSurface', 58), ('kCurveFromSurface', 58), ('curveFromSurfaceBnd', 59), ('kCurveFromSurfaceBnd', 59), ('curveFromSurfaceCoS', 60), ('kCurveFromSurfaceCoS', 60), ('curveFromSurfaceIso', 61), ('kCurveFromSurfaceIso', 61), ('curveInfo', 62), ('kCurveInfo', 62), ('detachCurve', 63), ('kDetachCurve', 63), ('detachSurface', 64), ('kDetachSurface', 64), ('extendCurve', 65), ('kExtendCurve', 65), ('extendSurface', 66), ('kExtendSurface', 66), ('extrude', 67), ('kExtrude', 67), ('FFblendSrf', 68), ('kFFblendSrf', 68), ('FFfilletSrf', 69), ('kFFfilletSrf', 69), ('filletCurve', 70), ('kFilletCurve', 70), ('fitBspline', 71), ('kFitBspline', 71), ('flow', 72), ('kFlow', 72), ('hardenPointCurve', 73), ('kHardenPointCurve', 73), ('illustratorCurve', 74), ('kIllustratorCurve', 74), ('insertKnotCrv', 75), ('kInsertKnotCrv', 75), ('insertKnotSrf', 76), ('kInsertKnotSrf', 76), ('intersectSurface', 77), ('kIntersectSurface', 77), ('nurbsTesselate', 78), ('kNurbsTesselate', 78), ('nurbsPlane', 79), ('kNurbsPlane', 79), ('nurbsCube', 80), ('kNurbsCube', 80), ('offsetCos', 81), ('kOffsetCos', 81), ('offsetCurve', 82), ('kOffsetCurve', 82), ('planarTrimSrf', 83), ('kPlanarTrimSrf', 83), ('pointOnCurveInfo', 84), ('kPointOnCurveInfo', 84), ('pointOnSurfaceInfo', 85), ('kPointOnSurfaceInfo', 85), ('primitive', 86), ('kPrimitive', 86), ('projectCurve', 87), ('kProjectCurve', 87), ('projectTangent', 88), ('kProjectTangent', 88), ('RBFsurface', 89), ('kRBFsurface', 89), ('rebuildCurve', 90), ('kRebuildCurve', 90), ('rebuildSurface', 91), ('kRebuildSurface', 91), ('reverseCurve', 92), ('kReverseCurve', 92), ('reverseSurface', 93), ('kReverseSurface', 93), ('revolve', 94), ('kRevolve', 94), ('revolvedPrimitive', 95), ('kRevolvedPrimitive', 95), ('cone', 96), ('kCone', 96), ('renderCone', 97), ('kRenderCone', 97), ('cylinder', 98), ('kCylinder', 98), ('sphere', 99), ('kSphere', 99), ('skin', 100), ('kSkin', 100), ('stitchSrf', 101), ('kStitchSrf', 101), ('subCurve', 102), ('kSubCurve', 102), ('surfaceInfo', 103), ('kSurfaceInfo', 103), ('textCurves', 104), ('kTextCurves', 104), ('trim', 105), ('kTrim', 105), ('untrim', 106), ('kUntrim', 106), ('dagNode', 107), ('kDagNode', 107), ('proxy', 108), ('kProxy', 108), ('underWorld', 109), ('kUnderWorld', 109), ('transform', 110), ('kTransform', 110), ('aimConstraint', 111), ('kAimConstraint', 111), ('lookAt', 112), ('kLookAt', 112), ('geometryConstraint', 113), ('kGeometryConstraint', 113), ('geometryVarGroup', 114), ('kGeometryVarGroup', 114), ('anyGeometryVarGroup', 115), ('kAnyGeometryVarGroup', 115), ('curveVarGroup', 116), ('kCurveVarGroup', 116), ('meshVarGroup', 117), ('kMeshVarGroup', 117), ('surfaceVarGroup', 118), ('kSurfaceVarGroup', 118), ('ikEffector', 119), ('kIkEffector', 119), ('ikHandle', 120), ('kIkHandle', 120), ('joint', 121), ('kJoint', 121), ('manipulator3D', 122), ('kManipulator3D', 122), ('arrowManip', 123), ('kArrowManip', 123), ('axesActionManip', 124), ('kAxesActionManip', 124), ('ballProjectionManip', 125), ('kBallProjectionManip', 125), ('circleManip', 126), ('kCircleManip', 126), ('screenAlignedCircleManip', 127), ('kScreenAlignedCircleManip', 127), ('circleSweepManip', 128), ('kCircleSweepManip', 128), ('concentricProjectionManip', 129), ('kConcentricProjectionManip', 129), ('cubicProjectionManip', 130), ('kCubicProjectionManip', 130), ('cylindricalProjectionManip', 131), ('kCylindricalProjectionManip', 131), ('discManip', 132), ('kDiscManip', 132), ('freePointManip', 133), ('kFreePointManip', 133), ('centerManip', 134), ('kCenterManip', 134), ('limitManip', 135), ('kLimitManip', 135), ('enableManip', 136), ('kEnableManip', 136), ('freePointTriadManip', 137), ('kFreePointTriadManip', 137), ('propMoveTriadManip', 138), ('kPropMoveTriadManip', 138), ('towPointManip', 139), ('kTowPointManip', 139), ('polyCreateToolManip', 140), ('kPolyCreateToolManip', 140), ('polySplitToolManip', 141), ('kPolySplitToolManip', 141), ('geometryOnLineManip', 142), ('kGeometryOnLineManip', 142), ('cameraPlaneManip', 143), ('kCameraPlaneManip', 143), ('toggleOnLineManip', 144), ('kToggleOnLineManip', 144), ('stateManip', 145), ('kStateManip', 145), ('isoparmManip', 146), ('kIsoparmManip', 146), ('lineManip', 147), ('kLineManip', 147), ('manipContainer', 148), ('kManipContainer', 148), ('averageCurveManip', 149), ('kAverageCurveManip', 149), ('barnDoorManip', 150), ('kBarnDoorManip', 150), ('bevelManip', 151), ('kBevelManip', 151), ('blendManip', 152), ('kBlendManip', 152), ('buttonManip', 153), ('kButtonManip', 153), ('cameraManip', 154), ('kCameraManip', 154), ('coiManip', 155), ('kCoiManip', 155), ('cpManip', 156), ('kCpManip', 156), ('createCVManip', 157), ('kCreateCVManip', 157), ('createEPManip', 158), ('kCreateEPManip', 158), ('curveEdManip', 159), ('kCurveEdManip', 159), ('curveSegmentManip', 160), ('kCurveSegmentManip', 160), ('directionManip', 161), ('kDirectionManip', 161), ('dofManip', 162), ('kDofManip', 162), ('dropoffManip', 163), ('kDropoffManip', 163), ('extendCurveDistanceManip', 164), ('kExtendCurveDistanceManip', 164), ('extrudeManip', 165), ('kExtrudeManip', 165), ('ikSplineManip', 166), ('kIkSplineManip', 166), ('ikRPManip', 167), ('kIkRPManip', 167), ('jointClusterManip', 168), ('kJointClusterManip', 168), ('lightManip', 169), ('kLightManip', 169), ('motionPathManip', 170), ('kMotionPathManip', 170), ('offsetCosManip', 171), ('kOffsetCosManip', 171), ('offsetCurveManip', 172), ('kOffsetCurveManip', 172), ('projectionManip', 173), ('kProjectionManip', 173), ('polyProjectionManip', 174), ('kPolyProjectionManip', 174), ('projectionUVManip', 175), ('kProjectionUVManip', 175), ('projectionMultiManip', 176), ('kProjectionMultiManip', 176), ('projectTangentManip', 177), ('kProjectTangentManip', 177), ('propModManip', 178), ('kPropModManip', 178), ('quadPtOnLineManip', 179), ('kQuadPtOnLineManip', 179), ('rbfSrfManip', 180), ('kRbfSrfManip', 180), ('reverseCurveManip', 181), ('kReverseCurveManip', 181), ('reverseCrvManip', 182), ('kReverseCrvManip', 182), ('reverseSurfaceManip', 183), ('kReverseSurfaceManip', 183), ('revolveManip', 184), ('kRevolveManip', 184), ('revolvedPrimitiveManip', 185), ('kRevolvedPrimitiveManip', 185), ('spotManip', 186), ('kSpotManip', 186), ('spotCylinderManip', 187), ('kSpotCylinderManip', 187), ('triplanarProjectionManip', 188), ('kTriplanarProjectionManip', 188), ('trsManip', 189), ('kTrsManip', 189), ('dblTrsManip', 190), ('kDblTrsManip', 190), ('pivotManip2D', 191), ('kPivotManip2D', 191), ('manip2DContainer', 192), ('kManip2DContainer', 192), ('polyMoveUVManip', 193), ('kPolyMoveUVManip', 193), ('polyMappingManip', 194), ('kPolyMappingManip', 194), ('polyModifierManip', 195), ('kPolyModifierManip', 195), ('polyMoveVertexManip', 196), ('kPolyMoveVertexManip', 196), ('polyVertexNormalManip', 197), ('kPolyVertexNormalManip', 197), ('texSmudgeUVManip', 198), ('kTexSmudgeUVManip', 198), ('texLatticeDeformManip', 199), ('kTexLatticeDeformManip', 199), ('texLattice', 200), ('kTexLattice', 200), ('texSmoothManip', 201), ('kTexSmoothManip', 201), ('trsTransManip', 202), ('kTrsTransManip', 202), ('trsInsertManip', 203), ('kTrsInsertManip', 203), ('trsXformManip', 204), ('kTrsXformManip', 204), ('manipulator2D', 205), ('kManipulator2D', 205), ('translateManip2D', 206), ('kTranslateManip2D', 206), ('planarProjectionManip', 207), ('kPlanarProjectionManip', 207), ('pointOnCurveManip', 208), ('kPointOnCurveManip', 208), ('towPointOnCurveManip', 209), ('kTowPointOnCurveManip', 209), ('markerManip', 210), ('kMarkerManip', 210), ('pointOnLineManip', 211), ('kPointOnLineManip', 211), ('pointOnSurfaceManip', 212), ('kPointOnSurfaceManip', 212), ('translateUVManip', 213), ('kTranslateUVManip', 213), ('rotateBoxManip', 214), ('kRotateBoxManip', 214), ('rotateManip', 215), ('kRotateManip', 215), ('handleRotateManip', 216), ('kHandleRotateManip', 216), ('rotateLimitsManip', 217), ('kRotateLimitsManip', 217), ('scaleLimitsManip', 218), ('kScaleLimitsManip', 218), ('scaleManip', 219), ('kScaleManip', 219), ('scalingBoxManip', 220), ('kScalingBoxManip', 220), ('scriptManip', 221), ('kScriptManip', 221), ('sphericalProjectionManip', 222), ('kSphericalProjectionManip', 222), ('textureManip3D', 223), ('kTextureManip3D', 223), ('toggleManip', 224), ('kToggleManip', 224), ('translateBoxManip', 225), ('kTranslateBoxManip', 225), ('translateLimitsManip', 226), ('kTranslateLimitsManip', 226), ('translateManip', 227), ('kTranslateManip', 227), ('trimManip', 228), ('kTrimManip', 228), ('jointTranslateManip', 229), ('kJointTranslateManip', 229), ('manipulator', 230), ('kManipulator', 230), ('circlePointManip', 231), ('kCirclePointManip', 231), ('dimensionManip', 232), ('kDimensionManip', 232), ('fixedLineManip', 233), ('kFixedLineManip', 233), ('lightProjectionGeometry', 234), ('kLightProjectionGeometry', 234), ('lineArrowManip', 235), ('kLineArrowManip', 235), ('pointManip', 236), ('kPointManip', 236), ('triadManip', 237), ('kTriadManip', 237), ('normalConstraint', 238), ('kNormalConstraint', 238), ('orientConstraint', 239), ('kOrientConstraint', 239), ('pointConstraint', 240), ('kPointConstraint', 240), ('symmetryConstraint', 241), ('kSymmetryConstraint', 241), ('parentConstraint', 242), ('kParentConstraint', 242), ('poleVectorConstraint', 243), ('kPoleVectorConstraint', 243), ('scaleConstraint', 244), ('kScaleConstraint', 244), ('tangentConstraint', 245), ('kTangentConstraint', 245), ('unknownTransform', 246), ('kUnknownTransform', 246), ('world', 247), ('kWorld', 247), ('shape', 248), ('kShape', 248), ('baseLattice', 249), ('kBaseLattice', 249), ('camera', 250), ('kCamera', 250), ('cluster', 251), ('kCluster', 251), ('softMod', 252), ('kSoftMod', 252), ('collision', 253), ('kCollision', 253), ('dummy', 254), ('kDummy', 254), ('emitter', 255), ('kEmitter', 255), ('field', 256), ('kField', 256), ('air', 257), ('kAir', 257), ('drag', 258), ('kDrag', 258), ('gravity', 259), ('kGravity', 259), ('newton', 260), ('kNewton', 260), ('radial', 261), ('kRadial', 261), ('turbulence', 262), ('kTurbulence', 262), ('uniform', 263), ('kUniform', 263), ('vortex', 264), ('kVortex', 264), ('geometric', 265), ('kGeometric', 265), ('curve', 266), ('kCurve', 266), ('nurbsCurve', 267), ('kNurbsCurve', 267), ('nurbsCurveGeom', 268), ('kNurbsCurveGeom', 268), ('dimension', 269), ('kDimension', 269), ('angle', 270), ('kAngle', 270), ('annotation', 271), ('kAnnotation', 271), ('distance', 272), ('kDistance', 272), ('arcLength', 273), ('kArcLength', 273), ('radius', 274), ('kRadius', 274), ('paramDimension', 275), ('kParamDimension', 275), ('directedDisc', 276), ('kDirectedDisc', 276), ('renderRect', 277), ('kRenderRect', 277), ('envFogShape', 278), ('kEnvFogShape', 278), ('lattice', 279), ('kLattice', 279), ('latticeGeom', 280), ('kLatticeGeom', 280), ('locator', 281), ('kLocator', 281), ('dropoffLocator', 282), ('kDropoffLocator', 282), ('marker', 283), ('kMarker', 283), ('orientationMarker', 284), ('kOrientationMarker', 284), ('positionMarker', 285), ('kPositionMarker', 285), ('orientationLocator', 286), ('kOrientationLocator', 286), ('trimLocator', 287), ('kTrimLocator', 287), ('plane', 288), ('kPlane', 288), ('sketchPlane', 289), ('kSketchPlane', 289), ('groundPlane', 290), ('kGroundPlane', 290), ('orthoGrid', 291), ('kOrthoGrid', 291), ('sprite', 292), ('kSprite', 292), ('surface', 293), ('kSurface', 293), ('nurbsSurface', 294), ('kNurbsSurface', 294), ('nurbsSurfaceGeom', 295), ('kNurbsSurfaceGeom', 295), ('mesh', 296), ('kMesh', 296), ('meshGeom', 297), ('kMeshGeom', 297), ('renderSphere', 298), ('kRenderSphere', 298), ('flexor', 299), ('kFlexor', 299), ('clusterFlexor', 300), ('kClusterFlexor', 300), ('guideLine', 301), ('kGuideLine', 301), ('light', 302), ('kLight', 302), ('ambientLight', 303), ('kAmbientLight', 303), ('nonAmbientLight', 304), ('kNonAmbientLight', 304), ('areaLight', 305), ('kAreaLight', 305), ('linearLight', 306), ('kLinearLight', 306), ('nonExtendedLight', 307), ('kNonExtendedLight', 307), ('directionalLight', 308), ('kDirectionalLight', 308), ('pointLight', 309), ('kPointLight', 309), ('spotLight', 310), ('kSpotLight', 310), ('particle', 311), ('kParticle', 311), ('polyToolFeedbackShape', 312), ('kPolyToolFeedbackShape', 312), ('rigidConstraint', 313), ('kRigidConstraint', 313), ('rigid', 314), ('kRigid', 314), ('spring', 315), ('kSpring', 315), ('unknownDag', 316), ('kUnknownDag', 316), ('defaultLightList', 317), ('kDefaultLightList', 317), ('deleteComponent', 318), ('kDeleteComponent', 318), ('dispatchCompute', 319), ('kDispatchCompute', 319), ('shadingEngine', 320), ('kShadingEngine', 320), ('displacementShader', 321), ('kDisplacementShader', 321), ('distanceBetween', 322), ('kDistanceBetween', 322), ('DOF', 323), ('kDOF', 323), ('dummyConnectable', 324), ('kDummyConnectable', 324), ('dynamicsController', 325), ('kDynamicsController', 325), ('geoConnectable', 326), ('kGeoConnectable', 326), ('expression', 327), ('kExpression', 327), ('extract', 328), ('kExtract', 328), ('filter', 329), ('kFilter', 329), ('filterClosestSample', 330), ('kFilterClosestSample', 330), ('filterEuler', 331), ('kFilterEuler', 331), ('filterSimplify', 332), ('kFilterSimplify', 332), ('gammaCorrect', 333), ('kGammaCorrect', 333), ('geometryFilt', 334), ('kGeometryFilt', 334), ('bendLattice', 335), ('kBendLattice', 335), ('blendShape', 336), ('kBlendShape', 336), ('combinationShape', 337), ('kCombinationShape', 337), ('bulgeLattice', 338), ('kBulgeLattice', 338), ('FFD', 339), ('kFFD', 339), ('ffdDualBase', 340), ('kFfdDualBase', 340), ('rigidDeform', 341), ('kRigidDeform', 341), ('sculpt', 342), ('kSculpt', 342), ('textureDeformer', 343), ('kTextureDeformer', 343), ('textureDeformerHandle', 344), ('kTextureDeformerHandle', 344), ('tweak', 345), ('kTweak', 345), ('weightGeometryFilt', 346), ('kWeightGeometryFilt', 346), ('clusterFilter', 347), ('kClusterFilter', 347), ('softModFilter', 348), ('kSoftModFilter', 348), ('jointCluster', 349), ('kJointCluster', 349), ('deltaMush', 350), ('kDeltaMush', 350), ('tension', 351), ('kTension', 351), ('proxWrap', 352), ('kProxWrap', 352), ('wire', 353), ('kWire', 353), ('groupId', 354), ('kGroupId', 354), ('groupParts', 355), ('kGroupParts', 355), ('guide', 356), ('kGuide', 356), ('hsvToRgb', 357), ('kHsvToRgb', 357), ('hyperGraphInfo', 358), ('kHyperGraphInfo', 358), ('hyperLayout', 359), ('kHyperLayout', 359), ('hyperView', 360), ('kHyperView', 360), ('ikSolver', 361), ('kIkSolver', 361), ('MCsolver', 362), ('kMCsolver', 362), ('PASolver', 363), ('kPASolver', 363), ('SCsolver', 364), ('kSCsolver', 364), ('RPsolver', 365), ('kRPsolver', 365), ('splineSolver', 366), ('kSplineSolver', 366), ('ikSystem', 367), ('kIkSystem', 367), ('imagePlane', 368), ('kImagePlane', 368), ('lambert', 369), ('kLambert', 369), ('reflect', 370), ('kReflect', 370), ('blinn', 371), ('kBlinn', 371), ('phong', 372), ('kPhong', 372), ('phongExplorer', 373), ('kPhongExplorer', 373), ('layeredShader', 374), ('kLayeredShader', 374), ('lightInfo', 375), ('kLightInfo', 375), ('leastSquares', 376), ('kLeastSquares', 376), ('lightFogMaterial', 377), ('kLightFogMaterial', 377), ('envFogMaterial', 378), ('kEnvFogMaterial', 378), ('lightList', 379), ('kLightList', 379), ('lightSource', 380), ('kLightSource', 380), ('luminance', 381), ('kLuminance', 381), ('makeGroup', 382), ('kMakeGroup', 382), ('material', 383), ('kMaterial', 383), ('diffuseMaterial', 384), ('kDiffuseMaterial', 384), ('lambertMaterial', 385), ('kLambertMaterial', 385), ('blinnMaterial', 386), ('kBlinnMaterial', 386), ('phongMaterial', 387), ('kPhongMaterial', 387), ('lightSourceMaterial', 388), ('kLightSourceMaterial', 388), ('materialInfo', 389), ('kMaterialInfo', 389), ('matrixAdd', 390), ('kMatrixAdd', 390), ('matrixHold', 391), ('kMatrixHold', 391), ('matrixMult', 392), ('kMatrixMult', 392), ('matrixPass', 393), ('kMatrixPass', 393), ('matrixWtAdd', 394), ('kMatrixWtAdd', 394), ('midModifier', 395), ('kMidModifier', 395), ('midModifierWithMatrix', 396), ('kMidModifierWithMatrix', 396), ('polyBevel', 397), ('kPolyBevel', 397), ('polyTweak', 398), ('kPolyTweak', 398), ('polyAppend', 399), ('kPolyAppend', 399), ('polyChipOff', 400), ('kPolyChipOff', 400), ('polyCloseBorder', 401), ('kPolyCloseBorder', 401), ('polyCollapseEdge', 402), ('kPolyCollapseEdge', 402), ('polyCollapseF', 403), ('kPolyCollapseF', 403), ('polyCylProj', 404), ('kPolyCylProj', 404), ('polyDelEdge', 405), ('kPolyDelEdge', 405), ('polyDelFacet', 406), ('kPolyDelFacet', 406), ('polyDelVertex', 407), ('kPolyDelVertex', 407), ('polyExtrudeFacet', 408), ('kPolyExtrudeFacet', 408), ('polyMapCut', 409), ('kPolyMapCut', 409), ('polyMapDel', 410), ('kPolyMapDel', 410), ('polyMapSew', 411), ('kPolyMapSew', 411), ('polyMergeEdge', 412), ('kPolyMergeEdge', 412), ('polyMergeFacet', 413), ('kPolyMergeFacet', 413), ('polyMoveEdge', 414), ('kPolyMoveEdge', 414), ('polyMoveFacet', 415), ('kPolyMoveFacet', 415), ('polyMoveFacetUV', 416), ('kPolyMoveFacetUV', 416), ('polyMoveUV', 417), ('kPolyMoveUV', 417), ('polyMoveVertex', 418), ('kPolyMoveVertex', 418), ('polyMoveVertexUV', 419), ('kPolyMoveVertexUV', 419), ('polyNormal', 420), ('kPolyNormal', 420), ('polyPlanProj', 421), ('kPolyPlanProj', 421), ('polyProj', 422), ('kPolyProj', 422), ('polyQuad', 423), ('kPolyQuad', 423), ('polySmooth', 424), ('kPolySmooth', 424), ('polySoftEdge', 425), ('kPolySoftEdge', 425), ('polySphProj', 426), ('kPolySphProj', 426), ('polySplit', 427), ('kPolySplit', 427), ('polySubdEdge', 428), ('kPolySubdEdge', 428), ('polySubdFacet', 429), ('kPolySubdFacet', 429), ('polyTriangulate', 430), ('kPolyTriangulate', 430), ('polyCreator', 431), ('kPolyCreator', 431), ('polyPrimitive', 432), ('kPolyPrimitive', 432), ('polyCone', 433), ('kPolyCone', 433), ('polyCube', 434), ('kPolyCube', 434), ('polyCylinder', 435), ('kPolyCylinder', 435), ('polyMesh', 436), ('kPolyMesh', 436), ('polySphere', 437), ('kPolySphere', 437), ('polyTorus', 438), ('kPolyTorus', 438), ('polyCreateFacet', 439), ('kPolyCreateFacet', 439), ('polyUnite', 440), ('kPolyUnite', 440), ('motionPath', 441), ('kMotionPath', 441), ('pluginMotionPathNode', 442), ('kPluginMotionPathNode', 442), ('multilisterLight', 443), ('kMultilisterLight', 443), ('multiplyDivide', 444), ('kMultiplyDivide', 444), ('oldGeometryConstraint', 445), ('kOldGeometryConstraint', 445), ('opticalFX', 446), ('kOpticalFX', 446), ('particleAgeMapper', 447), ('kParticleAgeMapper', 447), ('particleCloud', 448), ('kParticleCloud', 448), ('particleColorMapper', 449), ('kParticleColorMapper', 449), ('particleIncandecenceMapper', 450), ('kParticleIncandecenceMapper', 450), ('particleTransparencyMapper', 451), ('kParticleTransparencyMapper', 451), ('partition', 452), ('kPartition', 452), ('place2dTexture', 453), ('kPlace2dTexture', 453), ('place3dTexture', 454), ('kPlace3dTexture', 454), ('pluginDependNode', 455), ('kPluginDependNode', 455), ('pluginLocatorNode', 456), ('kPluginLocatorNode', 456), ('plusMinusAverage', 457), ('kPlusMinusAverage', 457), ('pointMatrixMult', 458), ('kPointMatrixMult', 458), ('polySeparate', 459), ('kPolySeparate', 459), ('postProcessList', 460), ('kPostProcessList', 460), ('projection', 461), ('kProjection', 461), ('record', 462), ('kRecord', 462), ('renderUtilityList', 463), ('kRenderUtilityList', 463), ('reverse', 464), ('kReverse', 464), ('rgbToHsv', 465), ('kRgbToHsv', 465), ('rigidSolver', 466), ('kRigidSolver', 466), ('set', 467), ('kSet', 467), ('textureBakeSet', 468), ('kTextureBakeSet', 468), ('vertexBakeSet', 469), ('kVertexBakeSet', 469), ('setRange', 470), ('kSetRange', 470), ('shaderGlow', 471), ('kShaderGlow', 471), ('shaderList', 472), ('kShaderList', 472), ('shadingMap', 473), ('kShadingMap', 473), ('samplerInfo', 474), ('kSamplerInfo', 474), ('shapeFragment', 475), ('kShapeFragment', 475), ('simpleVolumeShader', 476), ('kSimpleVolumeShader', 476), ('sl60', 477), ('kSl60', 477), ('snapshot', 478), ('kSnapshot', 478), ('storyBoard', 479), ('kStoryBoard', 479), ('summaryObject', 480), ('kSummaryObject', 480), ('super', 481), ('kSuper', 481), ('control', 482), ('kControl', 482), ('surfaceLuminance', 483), ('kSurfaceLuminance', 483), ('surfaceShader', 484), ('kSurfaceShader', 484), ('textureList', 485), ('kTextureList', 485), ('textureEnv', 486), ('kTextureEnv', 486), ('envBall', 487), ('kEnvBall', 487), ('envCube', 488), ('kEnvCube', 488), ('envChrome', 489), ('kEnvChrome', 489), ('envSky', 490), ('kEnvSky', 490), ('envSphere', 491), ('kEnvSphere', 491), ('texture2d', 492), ('kTexture2d', 492), ('bulge', 493), ('kBulge', 493), ('checker', 494), ('kChecker', 494), ('cloth', 495), ('kCloth', 495), ('fileTexture', 496), ('kFileTexture', 496), ('fractal', 497), ('kFractal', 497), ('grid', 498), ('kGrid', 498), ('mountain', 499), ('kMountain', 499), ('ramp', 500), ('kRamp', 500), ('stencil', 501), ('kStencil', 501), ('water', 502), ('kWater', 502), ('texture3d', 503), ('kTexture3d', 503), ('brownian', 504), ('kBrownian', 504), ('cloud', 505), ('kCloud', 505), ('crater', 506), ('kCrater', 506), ('granite', 507), ('kGranite', 507), ('leather', 508), ('kLeather', 508), ('marble', 509), ('kMarble', 509), ('rock', 510), ('kRock', 510), ('snow', 511), ('kSnow', 511), ('solidFractal', 512), ('kSolidFractal', 512), ('stucco', 513), ('kStucco', 513), ('txSl', 514), ('kTxSl', 514), ('wood', 515), ('kWood', 515), ('time', 516), ('kTime', 516), ('timeToUnitConversion', 517), ('kTimeToUnitConversion', 517), ('renderSetup', 518), ('kRenderSetup', 518), ('renderGlobals', 519), ('kRenderGlobals', 519), ('renderGlobalsList', 520), ('kRenderGlobalsList', 520), ('renderQuality', 521), ('kRenderQuality', 521), ('resolution', 522), ('kResolution', 522), ('hardwareRenderGlobals', 523), ('kHardwareRenderGlobals', 523), ('arrayMapper', 524), ('kArrayMapper', 524), ('unitConversion', 525), ('kUnitConversion', 525), ('unitToTimeConversion', 526), ('kUnitToTimeConversion', 526), ('useBackground', 527), ('kUseBackground', 527), ('unknown', 528), ('kUnknown', 528), ('vectorProduct', 529), ('kVectorProduct', 529), ('volumeShader', 530), ('kVolumeShader', 530), ('component', 531), ('kComponent', 531), ('curveCVComponent', 532), ('kCurveCVComponent', 532), ('curveEPComponent', 533), ('kCurveEPComponent', 533), ('curveKnotComponent', 534), ('kCurveKnotComponent', 534), ('curveParamComponent', 535), ('kCurveParamComponent', 535), ('isoparmComponent', 536), ('kIsoparmComponent', 536), ('pivotComponent', 537), ('kPivotComponent', 537), ('surfaceCVComponent', 538), ('kSurfaceCVComponent', 538), ('surfaceEPComponent', 539), ('kSurfaceEPComponent', 539), ('surfaceKnotComponent', 540), ('kSurfaceKnotComponent', 540), ('edgeComponent', 541), ('kEdgeComponent', 541), ('latticeComponent', 542), ('kLatticeComponent', 542), ('surfaceRangeComponent', 543), ('kSurfaceRangeComponent', 543), ('decayRegionCapComponent', 544), ('kDecayRegionCapComponent', 544), ('decayRegionComponent', 545), ('kDecayRegionComponent', 545), ('meshComponent', 546), ('kMeshComponent', 546), ('meshEdgeComponent', 547), ('kMeshEdgeComponent', 547), ('meshPolygonComponent', 548), ('kMeshPolygonComponent', 548), ('meshFrEdgeComponent', 549), ('kMeshFrEdgeComponent', 549), ('meshVertComponent', 550), ('kMeshVertComponent', 550), ('meshFaceVertComponent', 551), ('kMeshFaceVertComponent', 551), ('orientationComponent', 552), ('kOrientationComponent', 552), ('subVertexComponent', 553), ('kSubVertexComponent', 553), ('multiSubVertexComponent', 554), ('kMultiSubVertexComponent', 554), ('setGroupComponent', 555), ('kSetGroupComponent', 555), ('dynParticleSetComponent', 556), ('kDynParticleSetComponent', 556), ('selectionItem', 557), ('kSelectionItem', 557), ('dagSelectionItem', 558), ('kDagSelectionItem', 558), ('nonDagSelectionItem', 559), ('kNonDagSelectionItem', 559), ('itemList', 560), ('kItemList', 560), ('attribute', 561), ('kAttribute', 561), ('numericAttribute', 562), ('kNumericAttribute', 562), ('doubleAngleAttribute', 563), ('kDoubleAngleAttribute', 563), ('floatAngleAttribute', 564), ('kFloatAngleAttribute', 564), ('doubleLinearAttribute', 565), ('kDoubleLinearAttribute', 565), ('floatLinearAttribute', 566), ('kFloatLinearAttribute', 566), ('timeAttribute', 567), ('kTimeAttribute', 567), ('enumAttribute', 568), ('kEnumAttribute', 568), ('unitAttribute', 569), ('kUnitAttribute', 569), ('typedAttribute', 570), ('kTypedAttribute', 570), ('compoundAttribute', 571), ('kCompoundAttribute', 571), ('genericAttribute', 572), ('kGenericAttribute', 572), ('lightDataAttribute', 573), ('kLightDataAttribute', 573), ('matrixAttribute', 574), ('kMatrixAttribute', 574), ('floatMatrixAttribute', 575), ('kFloatMatrixAttribute', 575), ('messageAttribute', 576), ('kMessageAttribute', 576), ('plugin', 577), ('kPlugin', 577), ('data', 578), ('kData', 578), ('componentListData', 579), ('kComponentListData', 579), ('doubleArrayData', 580), ('kDoubleArrayData', 580), ('intArrayData', 581), ('kIntArrayData', 581), ('latticeData', 582), ('kLatticeData', 582), ('matrixData', 583), ('kMatrixData', 583), ('meshData', 584), ('kMeshData', 584), ('nurbsSurfaceData', 585), ('kNurbsSurfaceData', 585), ('nurbsCurveData', 586), ('kNurbsCurveData', 586), ('numericData', 587), ('kNumericData', 587), ('data2Double', 588), ('kData2Double', 588), ('data2Float', 589), ('kData2Float', 589), ('data2Long', 590), ('data2Int', 590), ('kData2Int', 590), ('kData2Long', 590), ('data2Short', 591), ('kData2Short', 591), ('data3Double', 592), ('kData3Double', 592), ('data3Float', 593), ('kData3Float', 593), ('data3Int', 594), ('data3Long', 594), ('kData3Int', 594), ('kData3Long', 594), ('data3Short', 595), ('kData3Short', 595), ('pluginData', 596), ('kPluginData', 596), ('pointArrayData', 597), ('kPointArrayData', 597), ('matrixArrayData', 598), ('kMatrixArrayData', 598), ('sphereData', 599), ('kSphereData', 599), ('stringData', 600), ('kStringData', 600), ('stringArrayData', 601), ('kStringArrayData', 601), ('vectorArrayData', 602), ('kVectorArrayData', 602), ('selectionList', 603), ('kSelectionList', 603), ('transformGeometry', 604), ('kTransformGeometry', 604), ('commEdgePtManip', 605), ('kCommEdgePtManip', 605), ('commEdgeOperManip', 606), ('kCommEdgeOperManip', 606), ('commEdgeSegmentManip', 607), ('kCommEdgeSegmentManip', 607), ('commCornerManip', 608), ('kCommCornerManip', 608), ('commCornerOperManip', 609), ('kCommCornerOperManip', 609), ('pluginDeformerNode', 610), ('kPluginDeformerNode', 610), ('torus', 611), ('kTorus', 611), ('polyBoolOp', 612), ('kPolyBoolOp', 612), ('singleShadingSwitch', 613), ('kSingleShadingSwitch', 613), ('doubleShadingSwitch', 614), ('kDoubleShadingSwitch', 614), ('tripleShadingSwitch', 615), ('kTripleShadingSwitch', 615), ('nurbsSquare', 616), ('kNurbsSquare', 616), ('anisotropy', 617), ('kAnisotropy', 617), ('nonLinear', 618), ('kNonLinear', 618), ('deformFunc', 619), ('kDeformFunc', 619), ('deformBend', 620), ('kDeformBend', 620), ('deformTwist', 621), ('kDeformTwist', 621), ('deformSquash', 622), ('kDeformSquash', 622), ('deformFlare', 623), ('kDeformFlare', 623), ('deformSine', 624), ('kDeformSine', 624), ('deformWave', 625), ('kDeformWave', 625), ('deformBendManip', 626), ('kDeformBendManip', 626), ('deformTwistManip', 627), ('kDeformTwistManip', 627), ('deformSquashManip', 628), ('kDeformSquashManip', 628), ('deformFlareManip', 629), ('kDeformFlareManip', 629), ('deformSineManip', 630), ('kDeformSineManip', 630), ('deformWaveManip', 631), ('kDeformWaveManip', 631), ('softModManip', 632), ('kSoftModManip', 632), ('distanceManip', 633), ('kDistanceManip', 633), ('script', 634), ('kScript', 634), ('curveFromMeshEdge', 635), ('kCurveFromMeshEdge', 635), ('curveCurveIntersect', 636), ('kCurveCurveIntersect', 636), ('nurbsCircular3PtArc', 637), ('kNurbsCircular3PtArc', 637), ('nurbsCircular2PtArc', 638), ('kNurbsCircular2PtArc', 638), ('offsetSurface', 639), ('kOffsetSurface', 639), ('roundConstantRadius', 640), ('kRoundConstantRadius', 640), ('roundRadiusManip', 641), ('kRoundRadiusManip', 641), ('roundRadiusCrvManip', 642), ('kRoundRadiusCrvManip', 642), ('roundConstantRadiusManip', 643), ('kRoundConstantRadiusManip', 643), ('threePointArcManip', 644), ('kThreePointArcManip', 644), ('twoPointArcManip', 645), ('kTwoPointArcManip', 645), ('textButtonManip', 646), ('kTextButtonManip', 646), ('offsetSurfaceManip', 647), ('kOffsetSurfaceManip', 647), ('imageData', 648), ('kImageData', 648), ('imageLoad', 649), ('kImageLoad', 649), ('imageSave', 650), ('kImageSave', 650), ('imageNetSrc', 651), ('kImageNetSrc', 651), ('imageNetDest', 652), ('kImageNetDest', 652), ('imageRender', 653), ('kImageRender', 653), ('imageAdd', 654), ('kImageAdd', 654), ('imageDiff', 655), ('kImageDiff', 655), ('imageMultiply', 656), ('kImageMultiply', 656), ('imageOver', 657), ('kImageOver', 657), ('imageUnder', 658), ('kImageUnder', 658), ('imageColorCorrect', 659), ('kImageColorCorrect', 659), ('imageBlur', 660), ('kImageBlur', 660), ('imageFilter', 661), ('kImageFilter', 661), ('imageDepth', 662), ('kImageDepth', 662), ('imageDisplay', 663), ('kImageDisplay', 663), ('imageView', 664), ('kImageView', 664), ('imageMotionBlur', 665), ('kImageMotionBlur', 665), ('viewColorManager', 666), ('kViewColorManager', 666), ('matrixFloatData', 667), ('kMatrixFloatData', 667), ('skinShader', 668), ('kSkinShader', 668), ('componentManip', 669), ('kComponentManip', 669), ('selectionListData', 670), ('kSelectionListData', 670), ('objectFilter', 671), ('kObjectFilter', 671), ('objectMultiFilter', 672), ('kObjectMultiFilter', 672), ('objectNameFilter', 673), ('kObjectNameFilter', 673), ('objectTypeFilter', 674), ('kObjectTypeFilter', 674), ('objectAttrFilter', 675), ('kObjectAttrFilter', 675), ('objectRenderFilter', 676), ('kObjectRenderFilter', 676), ('objectScriptFilter', 677), ('kObjectScriptFilter', 677), ('selectionListOperator', 678), ('kSelectionListOperator', 678), ('subdiv', 679), ('kSubdiv', 679), ('polyToSubdiv', 680), ('kPolyToSubdiv', 680), ('skinClusterFilter', 681), ('kSkinClusterFilter', 681), ('character', 683), ('kCharacter', 683), ('characterOffset', 684), ('kCharacterOffset', 684), ('dagPose', 685), ('kDagPose', 685), ('stitchAsNurbsShell', 686), ('kStitchAsNurbsShell', 686), ('explodeNurbsShell', 687), ('kExplodeNurbsShell', 687), ('nurbsBoolean', 688), ('kNurbsBoolean', 688), ('stitchSrfManip', 689), ('kStitchSrfManip', 689), ('forceUpdateManip', 690), ('kForceUpdateManip', 690), ('pluginManipContainer', 691), ('kPluginManipContainer', 691), ('polySewEdge', 692), ('kPolySewEdge', 692), ('polyMergeVert', 693), ('kPolyMergeVert', 693), ('polySmoothFacet', 694), ('kPolySmoothFacet', 694), ('smoothCurve', 695), ('kSmoothCurve', 695), ('globalStitch', 696), ('kGlobalStitch', 696), ('subdivCVComponent', 697), ('kSubdivCVComponent', 697), ('subdivEdgeComponent', 698), ('kSubdivEdgeComponent', 698), ('subdivFaceComponent', 699), ('kSubdivFaceComponent', 699), ('UVManip2D', 700), ('kUVManip2D', 700), ('translateUVManip2D', 701), ('kTranslateUVManip2D', 701), ('rotateUVManip2D', 702), ('kRotateUVManip2D', 702), ('scaleUVManip2D', 703), ('kScaleUVManip2D', 703), ('polyTweakUV', 704), ('kPolyTweakUV', 704), ('moveUVShellManip2D', 705), ('kMoveUVShellManip2D', 705), ('pluginShape', 706), ('kPluginShape', 706), ('geometryData', 707), ('kGeometryData', 707), ('singleIndexedComponent', 708), ('kSingleIndexedComponent', 708), ('doubleIndexedComponent', 709), ('kDoubleIndexedComponent', 709), ('tripleIndexedComponent', 710), ('kTripleIndexedComponent', 710), ('extendSurfaceDistanceManip', 711), ('kExtendSurfaceDistanceManip', 711), ('squareSrf', 712), ('kSquareSrf', 712), ('squareSrfManip', 713), ('kSquareSrfManip', 713), ('subdivToPoly', 714), ('kSubdivToPoly', 714), ('dynBase', 715), ('kDynBase', 715), ('dynEmitterManip', 716), ('kDynEmitterManip', 716), ('dynFieldsManip', 717), ('kDynFieldsManip', 717), ('dynBaseFieldManip', 718), ('kDynBaseFieldManip', 718), ('dynAirManip', 719), ('kDynAirManip', 719), ('dynNewtonManip', 720), ('kDynNewtonManip', 720), ('dynTurbulenceManip', 721), ('kDynTurbulenceManip', 721), ('dynSpreadManip', 722), ('kDynSpreadManip', 722), ('dynAttenuationManip', 723), ('kDynAttenuationManip', 723), ('dynArrayAttrsData', 724), ('kDynArrayAttrsData', 724), ('pluginFieldNode', 725), ('kPluginFieldNode', 725), ('pluginEmitterNode', 726), ('kPluginEmitterNode', 726), ('pluginSpringNode', 727), ('kPluginSpringNode', 727), ('displayLayer', 728), ('kDisplayLayer', 728), ('displayLayerManager', 729), ('kDisplayLayerManager', 729), ('polyColorPerVertex', 730), ('kPolyColorPerVertex', 730), ('createColorSet', 731), ('kCreateColorSet', 731), ('deleteColorSet', 732), ('kDeleteColorSet', 732), ('copyColorSet', 733), ('kCopyColorSet', 733), ('blendColorSet', 734), ('kBlendColorSet', 734), ('polyColorMod', 735), ('kPolyColorMod', 735), ('polyColorDel', 736), ('kPolyColorDel', 736), ('characterMappingData', 737), ('kCharacterMappingData', 737), ('dynSweptGeometryData', 738), ('kDynSweptGeometryData', 738), ('wrapFilter', 739), ('kWrapFilter', 739), ('meshVtxFaceComponent', 740), ('kMeshVtxFaceComponent', 740), ('binaryData', 741), ('kBinaryData', 741), ('attribute2Double', 742), ('kAttribute2Double', 742), ('attribute2Float', 743), ('kAttribute2Float', 743), ('attribute2Short', 744), ('kAttribute2Short', 744), ('attribute2Long', 745), ('attribute2Int', 745), ('kAttribute2Int', 745), ('kAttribute2Long', 745), ('attribute3Double', 746), ('kAttribute3Double', 746), ('attribute3Float', 747), ('kAttribute3Float', 747), ('attribute3Short', 748), ('kAttribute3Short', 748), ('attribute3Int', 749), ('attribute3Long', 749), ('kAttribute3Int', 749), ('kAttribute3Long', 749), ('reference', 750), ('kReference', 750), ('blindData', 751), ('kBlindData', 751), ('blindDataTemplate', 752), ('kBlindDataTemplate', 752), ('polyBlindData', 753), ('kPolyBlindData', 753), ('polyNormalPerVertex', 754), ('kPolyNormalPerVertex', 754), ('nurbsToSubdiv', 755), ('kNurbsToSubdiv', 755), ('pluginIkSolver', 756), ('kPluginIkSolver', 756), ('instancer', 757), ('kInstancer', 757), ('moveVertexManip', 758), ('kMoveVertexManip', 758), ('stroke', 759), ('kStroke', 759), ('brush', 760), ('kBrush', 760), ('strokeGlobals', 761), ('kStrokeGlobals', 761), ('pluginGeometryData', 762), ('kPluginGeometryData', 762), ('lightLink', 763), ('kLightLink', 763), ('dynGlobals', 764), ('kDynGlobals', 764), ('polyReduce', 765), ('kPolyReduce', 765), ('lodThresholds', 766), ('kLodThresholds', 766), ('chooser', 767), ('kChooser', 767), ('lodGroup', 768), ('kLodGroup', 768), ('multDoubleLinear', 769), ('kMultDoubleLinear', 769), ('fourByFourMatrix', 770), ('kFourByFourMatrix', 770), ('towPointOnSurfaceManip', 771), ('kTowPointOnSurfaceManip', 771), ('surfaceEdManip', 772), ('kSurfaceEdManip', 772), ('surfaceFaceComponent', 773), ('kSurfaceFaceComponent', 773), ('clipScheduler', 774), ('kClipScheduler', 774), ('clipLibrary', 775), ('kClipLibrary', 775), ('subSurface', 776), ('kSubSurface', 776), ('smoothTangentSrf', 777), ('kSmoothTangentSrf', 777), ('renderPass', 778), ('kRenderPass', 778), ('renderPassSet', 779), ('kRenderPassSet', 779), ('renderLayer', 780), ('kRenderLayer', 780), ('renderLayerManager', 781), ('kRenderLayerManager', 781), ('passContributionMap', 782), ('kPassContributionMap', 782), ('precompExport', 783), ('kPrecompExport', 783), ('renderTarget', 784), ('kRenderTarget', 784), ('renderedImageSource', 785), ('kRenderedImageSource', 785), ('imageSource', 786), ('kImageSource', 786), ('polyFlipEdge', 787), ('kPolyFlipEdge', 787), ('polyExtrudeEdge', 788), ('kPolyExtrudeEdge', 788), ('animBlend', 789), ('kAnimBlend', 789), ('animBlendInOut', 790), ('kAnimBlendInOut', 790), ('polyAppendVertex', 791), ('kPolyAppendVertex', 791), ('uvChooser', 792), ('kUvChooser', 792), ('subdivCompId', 793), ('kSubdivCompId', 793), ('volumeAxis', 794), ('kVolumeAxis', 794), ('deleteUVSet', 795), ('kDeleteUVSet', 795), ('subdHierBlind', 796), ('kSubdHierBlind', 796), ('subdBlindData', 797), ('kSubdBlindData', 797), ('characterMap', 798), ('kCharacterMap', 798), ('layeredTexture', 799), ('kLayeredTexture', 799), ('subdivCollapse', 800), ('kSubdivCollapse', 800), ('particleSamplerInfo', 801), ('kParticleSamplerInfo', 801), ('copyUVSet', 802), ('kCopyUVSet', 802), ('createUVSet', 803), ('kCreateUVSet', 803), ('clip', 804), ('kClip', 804), ('polySplitVert', 805), ('kPolySplitVert', 805), ('subdivData', 806), ('kSubdivData', 806), ('subdivGeom', 807), ('kSubdivGeom', 807), ('UInt64ArrayData', 808), ('kUInt64ArrayData', 808), ('int64ArrayData', 809), ('kInt64ArrayData', 809), ('polySplitEdge', 810), ('kPolySplitEdge', 810), ('subdivReverseFaces', 811), ('kSubdivReverseFaces', 811), ('meshMapComponent', 812), ('kMeshMapComponent', 812), ('sectionManip', 813), ('kSectionManip', 813), ('xsectionSubdivEdit', 814), ('kXsectionSubdivEdit', 814), ('subdivToNurbs', 815), ('kSubdivToNurbs', 815), ('editCurve', 816), ('kEditCurve', 816), ('editCurveManip', 817), ('kEditCurveManip', 817), ('crossSectionManager', 818), ('kCrossSectionManager', 818), ('createSectionManip', 819), ('kCreateSectionManip', 819), ('crossSectionEditManip', 820), ('kCrossSectionEditManip', 820), ('dropOffFunction', 821), ('kDropOffFunction', 821), ('subdBoolean', 822), ('kSubdBoolean', 822), ('subdModifyEdge', 823), ('kSubdModifyEdge', 823), ('modifyEdgeCrvManip', 824), ('kModifyEdgeCrvManip', 824), ('modifyEdgeManip', 825), ('kModifyEdgeManip', 825), ('scalePointManip', 826), ('kScalePointManip', 826), ('transformBoxManip', 827), ('kTransformBoxManip', 827), ('symmetryLocator', 828), ('kSymmetryLocator', 828), ('symmetryMapVector', 829), ('kSymmetryMapVector', 829), ('symmetryMapCurve', 830), ('kSymmetryMapCurve', 830), ('curveFromSubdivEdge', 831), ('kCurveFromSubdivEdge', 831), ('createBPManip', 832), ('kCreateBPManip', 832), ('modifyEdgeBaseManip', 833), ('kModifyEdgeBaseManip', 833), ('subdExtrudeFace', 834), ('kSubdExtrudeFace', 834), ('subdivSurfaceVarGroup', 835), ('kSubdivSurfaceVarGroup', 835), ('sfRevolveManip', 836), ('kSfRevolveManip', 836), ('curveFromSubdivFace', 837), ('kCurveFromSubdivFace', 837), ('unused1', 838), ('kUnused1', 838), ('unused2', 839), ('kUnused2', 839), ('unused3', 840), ('kUnused3', 840), ('unused4', 841), ('kUnused4', 841), ('unused5', 842), ('kUnused5', 842), ('unused6', 843), ('kUnused6', 843), ('polyTransfer', 844), ('kPolyTransfer', 844), ('polyAverageVertex', 845), ('kPolyAverageVertex', 845), ('polyAutoProj', 846), ('kPolyAutoProj', 846), ('polyLayoutUV', 847), ('kPolyLayoutUV', 847), ('polyMapSewMove', 848), ('kPolyMapSewMove', 848), ('subdModifier', 849), ('kSubdModifier', 849), ('subdMoveVertex', 850), ('kSubdMoveVertex', 850), ('subdMoveEdge', 851), ('kSubdMoveEdge', 851), ('subdMoveFace', 852), ('kSubdMoveFace', 852), ('subdDelFace', 853), ('kSubdDelFace', 853), ('snapshotShape', 854), ('kSnapshotShape', 854), ('subdivMapComponent', 855), ('kSubdivMapComponent', 855), ('jiggleDeformer', 856), ('kJiggleDeformer', 856), ('globalCacheControls', 857), ('kGlobalCacheControls', 857), ('diskCache', 858), ('kDiskCache', 858), ('subdCloseBorder', 859), ('kSubdCloseBorder', 859), ('subdMergeVert', 860), ('kSubdMergeVert', 860), ('boxData', 861), ('kBoxData', 861), ('box', 862), ('kBox', 862), ('renderBox', 863), ('kRenderBox', 863), ('subdSplitFace', 864), ('kSubdSplitFace', 864), ('volumeFog', 865), ('kVolumeFog', 865), ('subdTweakUV', 866), ('kSubdTweakUV', 866), ('subdMapCut', 867), ('kSubdMapCut', 867), ('subdLayoutUV', 868), ('kSubdLayoutUV', 868), ('subdMapSewMove', 869), ('kSubdMapSewMove', 869), ('ocean', 870), ('kOcean', 870), ('volumeNoise', 871), ('kVolumeNoise', 871), ('subdAutoProj', 872), ('kSubdAutoProj', 872), ('subdSubdivideFace', 873), ('kSubdSubdivideFace', 873), ('noise', 874), ('kNoise', 874), ('attribute4Double', 875), ('kAttribute4Double', 875), ('data4Double', 876), ('kData4Double', 876), ('subdPlanProj', 877), ('kSubdPlanProj', 877), ('subdTweak', 878), ('kSubdTweak', 878), ('subdProjectionManip', 879), ('kSubdProjectionManip', 879), ('subdMappingManip', 880), ('kSubdMappingManip', 880), ('hardwareReflectionMap', 881), ('kHardwareReflectionMap', 881), ('polyNormalizeUV', 882), ('kPolyNormalizeUV', 882), ('polyFlipUV', 883), ('kPolyFlipUV', 883), ('hwShaderNode', 884), ('kHwShaderNode', 884), ('pluginHardwareShader', 885), ('kPluginHardwareShader', 885), ('pluginHwShaderNode', 886), ('kPluginHwShaderNode', 886), ('subdAddTopology', 887), ('kSubdAddTopology', 887), ('subdCleanTopology', 888), ('kSubdCleanTopology', 888), ('implicitCone', 889), ('kImplicitCone', 889), ('implicitSphere', 890), ('kImplicitSphere', 890), ('rampShader', 891), ('kRampShader', 891), ('volumeLight', 892), ('kVolumeLight', 892), ('oceanShader', 893), ('kOceanShader', 893), ('bevelPlus', 894), ('kBevelPlus', 894), ('styleCurve', 895), ('kStyleCurve', 895), ('polyCut', 896), ('kPolyCut', 896), ('polyPoke', 897), ('kPolyPoke', 897), ('polyWedgeFace', 898), ('kPolyWedgeFace', 898), ('polyCutManipContainer', 899), ('kPolyCutManipContainer', 899), ('polyCutManip', 900), ('kPolyCutManip', 900), ('polyMirrorManipContainer', 901), ('kPolyMirrorManipContainer', 901), ('polyPokeManip', 902), ('kPolyPokeManip', 902), ('fluidTexture3D', 903), ('kFluidTexture3D', 903), ('fluidTexture2D', 904), ('kFluidTexture2D', 904), ('polyMergeUV', 905), ('kPolyMergeUV', 905), ('polyStraightenUVBorder', 906), ('kPolyStraightenUVBorder', 906), ('alignManip', 907), ('kAlignManip', 907), ('pluginTransformNode', 908), ('kPluginTransformNode', 908), ('fluid', 909), ('kFluid', 909), ('fluidGeom', 910), ('kFluidGeom', 910), ('fluidData', 911), ('kFluidData', 911), ('smear', 912), ('kSmear', 912), ('stringShadingSwitch', 913), ('kStringShadingSwitch', 913), ('studioClearCoat', 914), ('kStudioClearCoat', 914), ('fluidEmitter', 915), ('kFluidEmitter', 915), ('heightField', 916), ('kHeightField', 916), ('geoConnector', 917), ('kGeoConnector', 917), ('snapshotPath', 918), ('kSnapshotPath', 918), ('pluginObjectSet', 919), ('kPluginObjectSet', 919), ('quadShadingSwitch', 920), ('kQuadShadingSwitch', 920), ('polyExtrudeVertex', 921), ('kPolyExtrudeVertex', 921), ('pairBlend', 922), ('kPairBlend', 922), ('textManip', 923), ('kTextManip', 923), ('viewManip', 924), ('kViewManip', 924), ('xformManip', 925), ('kXformManip', 925), ('mute', 926), ('kMute', 926), ('constraint', 927), ('kConstraint', 927), ('trimWithBoundaries', 928), ('kTrimWithBoundaries', 928), ('curveFromMeshCoM', 929), ('kCurveFromMeshCoM', 929), ('follicle', 930), ('kFollicle', 930), ('hairSystem', 931), ('kHairSystem', 931), ('remapValue', 932), ('kRemapValue', 932), ('remapColor', 933), ('kRemapColor', 933), ('remapHsv', 934), ('kRemapHsv', 934), ('hairConstraint', 935), ('kHairConstraint', 935), ('timeFunction', 936), ('kTimeFunction', 936), ('mentalRayTexture', 937), ('kMentalRayTexture', 937), ('objectBinFilter', 938), ('kObjectBinFilter', 938), ('polySmoothProxy', 939), ('kPolySmoothProxy', 939), ('pfxGeometry', 940), ('kPfxGeometry', 940), ('pfxHair', 941), ('kPfxHair', 941), ('hairTubeShader', 942), ('kHairTubeShader', 942), ('psdFileTexture', 943), ('kPsdFileTexture', 943), ('keyframeDelta', 944), ('kKeyframeDelta', 944), ('keyframeDeltaMove', 945), ('kKeyframeDeltaMove', 945), ('keyframeDeltaScale', 946), ('kKeyframeDeltaScale', 946), ('keyframeDeltaAddRemove', 947), ('kKeyframeDeltaAddRemove', 947), ('keyframeDeltaBlockAddRemove', 948), ('kKeyframeDeltaBlockAddRemove', 948), ('keyframeDeltaInfType', 949), ('kKeyframeDeltaInfType', 949), ('keyframeDeltaTangent', 950), ('kKeyframeDeltaTangent', 950), ('keyframeDeltaWeighted', 951), ('kKeyframeDeltaWeighted', 951), ('keyframeDeltaBreakdown', 952), ('kKeyframeDeltaBreakdown', 952), ('polyMirror', 953), ('kPolyMirror', 953), ('polyCreaseEdge', 954), ('kPolyCreaseEdge', 954), ('polyPinUV', 955), ('kPolyPinUV', 955), ('hikEffector', 956), ('kHikEffector', 956), ('hikIKEffector', 957), ('kHikIKEffector', 957), ('hikFKJoint', 958), ('kHikFKJoint', 958), ('hikSolver', 959), ('kHikSolver', 959), ('hikHandle', 960), ('kHikHandle', 960), ('proxyManager', 961), ('kProxyManager', 961), ('polyAutoProjManip', 962), ('kPolyAutoProjManip', 962), ('polyPrism', 963), ('kPolyPrism', 963), ('polyPyramid', 964), ('kPolyPyramid', 964), ('polySplitRing', 965), ('kPolySplitRing', 965), ('pfxToon', 966), ('kPfxToon', 966), ('toonLineAttributes', 967), ('kToonLineAttributes', 967), ('polyDuplicateEdge', 968), ('kPolyDuplicateEdge', 968), ('facade', 969), ('kFacade', 969), ('materialFacade', 970), ('kMaterialFacade', 970), ('envFacade', 971), ('kEnvFacade', 971), ('AISEnvFacade', 972), ('kAISEnvFacade', 972), ('lineModifier', 973), ('kLineModifier', 973), ('polyArrow', 974), ('kPolyArrow', 974), ('polyPrimitiveMisc', 975), ('kPolyPrimitiveMisc', 975), ('polyPlatonicSolid', 976), ('kPolyPlatonicSolid', 976), ('polyPipe', 977), ('kPolyPipe', 977), ('hikFloorContactMarker', 978), ('kHikFloorContactMarker', 978), ('hikGroundPlane', 979), ('kHikGroundPlane', 979), ('polyComponentData', 980), ('kPolyComponentData', 980), ('polyHelix', 981), ('kPolyHelix', 981), ('cacheFile', 982), ('kCacheFile', 982), ('historySwitch', 983), ('kHistorySwitch', 983), ('closestPointOnMesh', 984), ('kClosestPointOnMesh', 984), ('transferAttributes', 985), ('kTransferAttributes', 985), ('dynamicConstraint', 986), ('kDynamicConstraint', 986), ('NComponent', 987), ('kNComponent', 987), ('polyBridgeEdge', 988), ('kPolyBridgeEdge', 988), ('cacheableNode', 989), ('kCacheableNode', 989), ('nucleus', 990), ('kNucleus', 990), ('NBase', 991), ('kNBase', 991), ('cacheBase', 992), ('kCacheBase', 992), ('cacheBlend', 993), ('kCacheBlend', 993), ('cacheTrack', 994), ('kCacheTrack', 994), ('keyframeRegionManip', 995), ('kKeyframeRegionManip', 995), ('curveNormalizerAngle', 996), ('kCurveNormalizerAngle', 996), ('curveNormalizerLinear', 997), ('kCurveNormalizerLinear', 997), ('hyperLayoutDG', 998), ('kHyperLayoutDG', 998), ('pluginImagePlaneNode', 999), ('kPluginImagePlaneNode', 999), ('NCloth', 1000), ('kNCloth', 1000), ('NParticle', 1001), ('kNParticle', 1001), ('NRigid', 1002), ('kNRigid', 1002), ('pluginParticleAttributeMapperNode', 1003), ('kPluginParticleAttributeMapperNode', 1003), ('cameraSet', 1004), ('kCameraSet', 1004), ('pluginCameraSet', 1005), ('kPluginCameraSet', 1005), ('container', 1006), ('kContainer', 1006), ('floatVectorArrayData', 1007), ('kFloatVectorArrayData', 1007), ('NObjectData', 1008), ('kNObjectData', 1008), ('NObject', 1009), ('kNObject', 1009), ('pluginConstraintNode', 1010), ('kPluginConstraintNode', 1010), ('asset', 1011), ('kAsset', 1011), ('polyEdgeToCurve', 1012), ('kPolyEdgeToCurve', 1012), ('animLayer', 1013), ('kAnimLayer', 1013), ('blendNodeBase', 1014), ('kBlendNodeBase', 1014), ('blendNodeBoolean', 1015), ('kBlendNodeBoolean', 1015), ('blendNodeDouble', 1016), ('kBlendNodeDouble', 1016), ('blendNodeDoubleAngle', 1017), ('kBlendNodeDoubleAngle', 1017), ('blendNodeDoubleLinear', 1018), ('kBlendNodeDoubleLinear', 1018), ('blendNodeEnum', 1019), ('kBlendNodeEnum', 1019), ('blendNodeFloat', 1020), ('kBlendNodeFloat', 1020), ('blendNodeFloatAngle', 1021), ('kBlendNodeFloatAngle', 1021), ('blendNodeFloatLinear', 1022), ('kBlendNodeFloatLinear', 1022), ('blendNodeInt16', 1023), ('kBlendNodeInt16', 1023), ('blendNodeInt32', 1024), ('kBlendNodeInt32', 1024), ('blendNodeAdditiveScale', 1025), ('kBlendNodeAdditiveScale', 1025), ('blendNodeAdditiveRotation', 1026), ('kBlendNodeAdditiveRotation', 1026), ('pluginManipulatorNode', 1027), ('kPluginManipulatorNode', 1027), ('NIdData', 1028), ('kNIdData', 1028), ('NId', 1029), ('kNId', 1029), ('floatArrayData', 1030), ('kFloatArrayData', 1030), ('membrane', 1031), ('kMembrane', 1031), ('mergeVertsToolManip', 1032), ('kMergeVertsToolManip', 1032), ('uint64SingleIndexedComponent', 1033), ('kUint64SingleIndexedComponent', 1033), ('polyToolFeedbackManip', 1034), ('kPolyToolFeedbackManip', 1034), ('polySelectEditFeedbackManip', 1035), ('kPolySelectEditFeedbackManip', 1035), ('writeToFrameBuffer', 1036), ('kWriteToFrameBuffer', 1036), ('writeToColorBuffer', 1037), ('kWriteToColorBuffer', 1037), ('writeToVectorBuffer', 1038), ('kWriteToVectorBuffer', 1038), ('writeToDepthBuffer', 1039), ('kWriteToDepthBuffer', 1039), ('writeToLabelBuffer', 1040), ('kWriteToLabelBuffer', 1040), ('stereoCameraMaster', 1041), ('kStereoCameraMaster', 1041), ('blendNodeTime', 1045), ('kBlendNodeTime', 1045), ('createBezierManip', 1046), ('kCreateBezierManip', 1046), ('bezierCurve', 1047), ('kBezierCurve', 1047), ('bezierCurveData', 1048), ('kBezierCurveData', 1048), ('nurbsCurveToBezier', 1049), ('kNurbsCurveToBezier', 1049), ('bezierCurveToNurbs', 1050), ('kBezierCurveToNurbs', 1050), ('polySpinEdge', 1051), ('kPolySpinEdge', 1051), ('polyHoleFace', 1052), ('kPolyHoleFace', 1052), ('pointOnPolyConstraint', 1053), ('kPointOnPolyConstraint', 1053), ('polyConnectComponents', 1054), ('kPolyConnectComponents', 1054), ('skinBinding', 1055), ('kSkinBinding', 1055), ('volumeBindManip', 1056), ('kVolumeBindManip', 1056), ('vertexWeightSet', 1057), ('kVertexWeightSet', 1057), ('nearestPointOnCurve', 1058), ('kNearestPointOnCurve', 1058), ('colorProfile', 1059), ('kColorProfile', 1059), ('adskMaterial', 1060), ('kAdskMaterial', 1060), ('containerBase', 1061), ('kContainerBase', 1061), ('dagContainer', 1062), ('kDagContainer', 1062), ('polyUVRectangle', 1063), ('kPolyUVRectangle', 1063), ('hardwareRenderingGlobals', 1064), ('kHardwareRenderingGlobals', 1064), ('polyProjectCurve', 1065), ('kPolyProjectCurve', 1065), ('renderingList', 1066), ('kRenderingList', 1066), ('polyExtrudeManip', 1067), ('kPolyExtrudeManip', 1067), ('polyExtrudeManipContainer', 1068), ('kPolyExtrudeManipContainer', 1068), ('threadedDevice', 1069), ('kThreadedDevice', 1069), ('clientDevice', 1070), ('kClientDevice', 1070), ('pluginClientDevice', 1071), ('kPluginClientDevice', 1071), ('pluginThreadedDevice', 1072), ('kPluginThreadedDevice', 1072), ('timeWarp', 1073), ('kTimeWarp', 1073), ('assembly', 1074), ('kAssembly', 1074), ('clipGhostShape', 1075), ('kClipGhostShape', 1075), ('clipToGhostData', 1076), ('kClipToGhostData', 1076), ('mandelbrot', 1077), ('kMandelbrot', 1077), ('mandelbrot3D', 1078), ('kMandelbrot3D', 1078), ('greasePlane', 1079), ('kGreasePlane', 1079), ('greasePlaneRenderShape', 1080), ('kGreasePlaneRenderShape', 1080), ('greasePencilSequence', 1081), ('kGreasePencilSequence', 1081), ('editMetadata', 1082), ('kEditMetadata', 1082), ('creaseSet', 1083), ('kCreaseSet', 1083), ('polyEditEdgeFlow', 1084), ('kPolyEditEdgeFlow', 1084), ('fosterParent', 1085), ('kFosterParent', 1085), ('snapUVManip2D', 1086), ('kSnapUVManip2D', 1086), ('toolContext', 1087), ('kToolContext', 1087), ('NLE', 1088), ('kNLE', 1088), ('shrinkWrapFilter', 1089), ('kShrinkWrapFilter', 1089), ('editsManager', 1090), ('kEditsManager', 1090), ('polyBevel2', 1091), ('kPolyBevel2', 1091), ('polyCBoolOp', 1092), ('kPolyCBoolOp', 1092), ('geomBind', 1093), ('kGeomBind', 1093), ('colorMgtGlobals', 1094), ('kColorMgtGlobals', 1094), ('polyBevel3', 1095), ('kPolyBevel3', 1095), ('timeEditorClipBase', 1096), ('kTimeEditorClipBase', 1096), ('timeEditorClipEvaluator', 1097), ('kTimeEditorClipEvaluator', 1097), ('timeEditorClip', 1098), ('kTimeEditorClip', 1098), ('timeEditor', 1099), ('kTimeEditor', 1099), ('timeEditorTracks', 1100), ('kTimeEditorTracks', 1100), ('timeEditorInterpolator', 1101), ('kTimeEditorInterpolator', 1101), ('timeEditorAnimSource', 1102), ('kTimeEditorAnimSource', 1102), ('caddyManipBase', 1103), ('kCaddyManipBase', 1103), ('polyCaddyManip', 1104), ('kPolyCaddyManip', 1104), ('polyModifierManipContainer', 1105), ('kPolyModifierManipContainer', 1105), ('polyRemesh', 1106), ('kPolyRemesh', 1106), ('polyContourProj', 1107), ('kPolyContourProj', 1107), ('contourProjectionManip', 1108), ('kContourProjectionManip', 1108), ('nodeGraphEditorInfo', 1109), ('kNodeGraphEditorInfo', 1109), ('nodeGraphEditorBookmarks', 1110), ('kNodeGraphEditorBookmarks', 1110), ('nodeGraphEditorBookmarkInfo', 1111), ('kNodeGraphEditorBookmarkInfo', 1111), ('pluginSkinCluster', 1112), ('kPluginSkinCluster', 1112), ('pluginGeometryFilter', 1113), ('kPluginGeometryFilter', 1113), ('pluginBlendShape', 1114), ('kPluginBlendShape', 1114), ('trackInfoManager', 1116), ('kTrackInfoManager', 1116), ('polyClean', 1117), ('kPolyClean', 1117), ('shapeEditorManager', 1118), ('kShapeEditorManager', 1118), ('oceanDeformer', 1119), ('kOceanDeformer', 1119), ('poseInterpolatorManager', 1120), ('kPoseInterpolatorManager', 1120), ('controllerTag', 1121), ('kControllerTag', 1121), ('reForm', 1122), ('kReForm', 1122), ('customEvaluatorClusterNode', 1123), ('kCustomEvaluatorClusterNode', 1123), ('polyCircularize', 1124), ('kPolyCircularize', 1124), ('last', 1127), ('kLast', 1127)], multiKeys=True)"}},
  'MFnAirField': {'enums': {},
                  'invertibles': [('setInheritRotation', 'inheritRotation'),
                                  ('setDirection', 'direction'),
                                  ('setSpread', 'spread'),
                                  ('setSpeed', 'speed'),
                                  ('setInheritVelocity', 'inheritVelocity'),
                                  ('setComponentOnly', 'componentOnly'),
                                  ('setEnableSpread', 'enableSpread')],
                  'methods': {'componentOnly': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\nReturns true if the air field will apply force only in the direction specified by the combination of its direction, speed, and inherit velocity attributes. Returns false if the force is made to effect the object's velocity to match the air field's velocity.",
                                                 'inArgs': [],
                                                 'inverse': ('setComponentOnly',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true Force applied only in direction of attributes.  false Force applied to match velocities.  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                              'direction': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the direction the air is blowing.',
                                             'inArgs': [],
                                             'inverse': ('setDirection',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A vector representing direction.',
                                                            'qualifiers': [],
                                                            'type': 'MVector'},
                                             'returnType': 'MVector',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                              'enableSpread': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns true if the air field is using the spread angle to define the influence of the air field.',
                                                'inArgs': [],
                                                'inverse': ('setEnableSpread',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' true Objects are affected in the area of the spread angle.  false Objects are affected by the max distance setting.  ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                              'inheritRotation': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns true if the air field is rotating or parented to a rotating object, and will undergo that same rotation.',
                                                   'inArgs': [],
                                                   'inverse': ('setInheritRotation',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true Rotations will change the direction the air field points.  false Rotations do not change the air field direction.  ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                              'inheritVelocity': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\nReturns the amount of the moving air field's velocity that is added to the direction and magnitude of the wind.",
                                                   'inArgs': [],
                                                   'inverse': ('setInheritVelocity',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'A value from 0 to 1 representing the amount of velocity added.',
                                                                  'qualifiers': [],
                                                                  'type': 'double'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                              'setComponentOnly': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable combination of attributes.',
                                                                           'type': 'bool'}},
                                                    'args': [('enable',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nEnables the air field to apply force specified as a combination of its direction, speed, and inherit veloicty attributes.',
                                                    'inArgs': ['enable'],
                                                    'inverse': ('componentOnly',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'enable': []},
                                                    'types': {'enable': 'bool'}}],
                              'setDirection': [{'argInfo': {'airDirection': {'doc': 'A vector representing direction.',
                                                                             'type': 'MVector'}},
                                                'args': [('airDirection',
                                                          'MVector',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSets the direction vector for the air to blow.',
                                                'inArgs': ['airDirection'],
                                                'inverse': ('direction',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'airDirection': ['const',
                                                                                    '&']},
                                                'types': {'airDirection': 'MVector'}}],
                              'setEnableSpread': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable use of the spread angle.',
                                                                          'type': 'bool'}},
                                                   'args': [('enable',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nEnables the air field to influence objects based on the spread angle setting.',
                                                   'inArgs': ['enable'],
                                                   'inverse': ('enableSpread',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'enable': []},
                                                   'types': {'enable': 'bool'}}],
                              'setInheritRotation': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable rotations effects.',
                                                                             'type': 'bool'}},
                                                      'args': [('enable',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nEnables the air field to undergo rotations and effect the direction that the air field points.',
                                                      'inArgs': ['enable'],
                                                      'inverse': ('inheritRotation',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'enable': []},
                                                      'types': {'enable': 'bool'}}],
                              'setInheritVelocity': [{'argInfo': {'velocity': {'doc': 'A value from 0 to 1 representing the amount of velocity that is added.',
                                                                               'type': 'double'}},
                                                      'args': [('velocity',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\nSets the amount of the moving air field's velocity that is added to the direction and magnitude of the wind.",
                                                      'inArgs': ['velocity'],
                                                      'inverse': ('inheritVelocity',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'velocity': []},
                                                      'types': {'velocity': 'double'}}],
                              'setSpeed': [{'argInfo': {'value': {'doc': 'A value representing speed.  A value of 0 is equivalent of turning the air field off.  A value of 1 and objects will match the velocity almost instantaneously.  ',
                                                                  'type': 'double'}},
                                            'args': [('value',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSets the control setting on how quickly the objects match the velocity of the air field.',
                                            'inArgs': ['value'],
                                            'inverse': ('speed', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'value': []},
                                            'types': {'value': 'double'}}],
                              'setSpread': [{'argInfo': {'value': {'doc': 'A value representing an angle.  A value of 0 effects objects only exactly in front of the direction vector.  A value of 1 effects objects in front by 180 degrees along the direction vector.  ',
                                                                   'type': 'double',
                                                                   'unitType': u'angular'}},
                                             'args': [('value',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSets the value representing an angle which objects are affected by the air fields direction setting. This value is taken into account when the Enable Spread attribute is turned on.',
                                             'inArgs': ['value'],
                                             'inverse': ('spread', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'value': []},
                                             'types': {'value': 'double'}}],
                              'speed': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the control setting on how quickly objects match the velocity of the air field.',
                                         'inArgs': [],
                                         'inverse': ('setSpeed', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The value of the speed setting.',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'spread': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns a value that represents an angle which objects are affected by the air fields direction setting. This value is taken into account when the Enable Spread attribute is turned on.',
                                          'inArgs': [],
                                          'inverse': ('setSpread', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' A value from 0 to 1 representing an angle.  A value of 0 effects objects only exactly in front of the direction vector.  A value of 1 effects objects in front by 180 degrees along the direction vector.  ',
                                                         'qualifiers': [],
                                                         'type': 'double',
                                                         'unitType': u'angular'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nFunction set type. \n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MFn',
                                                                'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'componentOnly': 'getComponentOnly',
                                   'direction': 'getDirection',
                                   'enableSpread': 'getEnableSpread',
                                   'inheritRotation': 'getInheritRotation',
                                   'inheritVelocity': 'getInheritVelocity',
                                   'speed': 'getSpeed',
                                   'spread': 'getSpread'}},
  'MFnAmbientLight': {'enums': {},
                      'invertibles': [('setCastSoftShadows',
                                       'castSoftShadows'),
                                      ('setAmbientShade', 'ambientShade'),
                                      ('setShadowRadius', 'shadowRadius')],
                      'methods': {'ambientShade': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nRetrieves the value of the "ambientShade" attribute of an ambient light node. This attribute determines how positional the light is. A value of 0 represents a completely ambient light, while a value of 1 represents a point light.',
                                                    'inArgs': [],
                                                    'inverse': ('setAmbientShade',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the "ambientShade" attribute of the ambient light node.',
                                                                   'qualifiers': [],
                                                                   'type': 'float'},
                                                    'returnType': 'float',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                  'castSoftShadows': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nRetrieves the value of the "castSoftShadows" attribute of an ambient light node. This attribute determines whether or not the light casts soft shadows.',
                                                       'inArgs': [],
                                                       'inverse': ('setCastSoftShadows',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The value of the "castSoftShadows" attribute of the ambient light node.',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nClass name. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                        'type': 'bool'}},
                                              'args': [('UIvisible',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'UIvisible': True},
                                              'deprecated': False,
                                              'doc': '\nCreates a new ambient light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                              'inArgs': ['UIvisible'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'UIvisible': []},
                                              'types': {'UIvisible': 'bool'}},
                                             {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                        'type': 'bool'},
                                                          'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                     'type': 'MObject'},
                                                          'wantTransform': {'doc': "Boolean to indicate whether the transform node is needed or not, which is 'false' by default. ",
                                                                            'type': 'bool'}},
                                              'args': [('parent',
                                                        'MObject',
                                                        'in'),
                                                       ('UIvisible',
                                                        'bool',
                                                        'in'),
                                                       ('wantTransform',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'UIvisible': True,
                                                           'wantTransform': False},
                                              'deprecated': False,
                                              'doc': '\nCreates a new ambient light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                              'inArgs': ['parent',
                                                         'UIvisible',
                                                         'wantTransform'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'UIvisible': [],
                                                                 'parent': ['const',
                                                                            '&'],
                                                                 'wantTransform': []},
                                              'types': {'UIvisible': 'bool',
                                                        'parent': 'MObject',
                                                        'wantTransform': 'bool'}},
                                             {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                        'type': 'bool'},
                                                          'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                     'type': 'MObject'}},
                                              'args': [('parent',
                                                        'MObject',
                                                        'in'),
                                                       ('UIvisible',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'UIvisible': True},
                                              'deprecated': False,
                                              'doc': '\nNO SCRIPT SUPPORT. \n',
                                              'inArgs': ['parent',
                                                         'UIvisible'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'UIvisible': [],
                                                                 'parent': ['const',
                                                                            '&']},
                                              'types': {'UIvisible': 'bool',
                                                        'parent': 'MObject'}}],
                                  'setAmbientShade': [{'argInfo': {'ambient_shade': {'doc': 'value to which the attribute will be set.',
                                                                                     'type': 'float'}},
                                                       'args': [('ambient_shade',
                                                                 'float',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets the value of the "ambientShade" attribute of an ambient light node.',
                                                       'inArgs': ['ambient_shade'],
                                                       'inverse': ('ambientShade',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'ambient_shade': ['const',
                                                                                            '&']},
                                                       'types': {'ambient_shade': 'float'}}],
                                  'setCastSoftShadows': [{'argInfo': {'cast_soft_shadows': {'doc': 'value to which the attribute will be set.',
                                                                                            'type': 'bool'}},
                                                          'args': [('cast_soft_shadows',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the value of the "castSoftShadows" attribute of an ambient light node.',
                                                          'inArgs': ['cast_soft_shadows'],
                                                          'inverse': ('castSoftShadows',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'cast_soft_shadows': ['const',
                                                                                                   '&']},
                                                          'types': {'cast_soft_shadows': 'bool'}}],
                                  'setShadowRadius': [{'argInfo': {'shadow_radius': {'doc': 'value to which the attribute will be set.',
                                                                                     'type': 'float'}},
                                                       'args': [('shadow_radius',
                                                                 'float',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets the value of the "shadowRadius" attribute of an ambient light node.',
                                                       'inArgs': ['shadow_radius'],
                                                       'inverse': ('shadowRadius',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'shadow_radius': ['const',
                                                                                            '&']},
                                                       'types': {'shadow_radius': 'float'}}],
                                  'shadowRadius': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nRetrieves the value of the "shadowRadius" attribute of an ambient light node. This attribute represents the radius of the light used when computing soft shadows. Higher radius values result in more extended soft shadows.',
                                                    'inArgs': [],
                                                    'inverse': ('setShadowRadius',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the "shadowRadius" attribute of the ambient light node.',
                                                                   'qualifiers': [],
                                                                   'type': 'float'},
                                                    'returnType': 'float',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFunction set type. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'ambientShade': 'getAmbientShade',
                                       'castSoftShadows': 'getCastSoftShadows',
                                       'shadowRadius': 'getShadowRadius'}},
  'MFnAnimCurve': {'enums': {'AnimCurveType': {'valueDocs': {'TA': 'Time to Angular.',
                                                             'TL': 'Time to Linear.',
                                                             'TT': 'Time to Time.',
                                                             'TU': 'Time to Unitless.',
                                                             'UA': 'Unitless to Angular.',
                                                             'UL': 'Unitless to Linear.',
                                                             'UT': 'Unitless to Time.',
                                                             'UU': 'Unitless to Unitless.',
                                                             'kAnimCurveTA': 'Time to Angular.',
                                                             'kAnimCurveTL': 'Time to Linear.',
                                                             'kAnimCurveTT': 'Time to Time.',
                                                             'kAnimCurveTU': 'Time to Unitless.',
                                                             'kAnimCurveUA': 'Unitless to Angular.',
                                                             'kAnimCurveUL': 'Unitless to Linear.',
                                                             'kAnimCurveUT': 'Unitless to Time.',
                                                             'kAnimCurveUU': 'Unitless to Unitless.',
                                                             'kAnimCurveUnknown': 'Unknown type.',
                                                             'unknown': 'Unknown type.'},
                                               'values': "Enum('AnimCurveType', {'kAnimCurveTA': 0, 'kAnimCurveTL': 1, 'kAnimCurveTT': 2, 'kAnimCurveTU': 3, 'kAnimCurveUA': 4, 'kAnimCurveUL': 5, 'kAnimCurveUT': 6, 'kAnimCurveUU': 7, 'kAnimCurveUnknown': 8})"},
                             'InfinityType': {'valueDocs': {'constant': 'Constant.',
                                                            'cycle': 'Cycle.',
                                                            'cycleRelative': 'Cycle relative.',
                                                            'kConstant': 'Constant.',
                                                            'kCycle': 'Cycle.',
                                                            'kCycleRelative': 'Cycle relative.',
                                                            'kLinear': 'Linear.',
                                                            'kOscillate': 'Oscillate.',
                                                            'linear': 'Linear.',
                                                            'oscillate': 'Oscillate.'},
                                              'values': "Enum('InfinityType', {'kConstant': 0, 'kLinear': 1, 'kCycle': 3, 'kCycleRelative': 4, 'kOscillate': 5})"},
                             'TangentType': {'valueDocs': {'auto': 'Auto.',
                                                           'clamped': 'Clamped.',
                                                           'fast': 'OBSOLETE kTangentFast should not be used. Using this tangent type may produce unwanted and unexpected results.',
                                                           'fixed': 'Fixed.',
                                                           'flat': 'Flag.',
                                                           'global_': 'Global.',
                                                           'kTangentAuto': 'Auto.',
                                                           'kTangentClamped': 'Clamped.',
                                                           'kTangentFast': 'OBSOLETE kTangentFast should not be used. Using this tangent type may produce unwanted and unexpected results.',
                                                           'kTangentFixed': 'Fixed.',
                                                           'kTangentFlat': 'Flag.',
                                                           'kTangentGlobal': 'Global.',
                                                           'kTangentLinear': 'Linear.',
                                                           'kTangentPlateau': 'Plateau.',
                                                           'kTangentSlow': 'OBSOLETE kTangentSlow should not be used. Using this tangent type may produce unwanted and unexpected results.',
                                                           'kTangentSmooth': 'Smooth.',
                                                           'kTangentStep': 'Step.',
                                                           'kTangentStepNext': 'StepNext.',
                                                           'linear': 'Linear.',
                                                           'plateau': 'Plateau.',
                                                           'slow': 'OBSOLETE kTangentSlow should not be used. Using this tangent type may produce unwanted and unexpected results.',
                                                           'smooth': 'Smooth.',
                                                           'step': 'Step.',
                                                           'stepNext': 'StepNext.'},
                                             'values': "Enum('TangentType', {'kTangentGlobal': 0, 'kTangentFixed': 1, 'kTangentLinear': 2, 'kTangentFlat': 3, 'kTangentSmooth': 4, 'kTangentStep': 5, 'kTangentSlow': 6, 'kTangentFast': 7, 'kTangentClamped': 8, 'kTangentPlateau': 9, 'kTangentStepNext': 10, 'kTangentAuto': 11})"}},
                   'invertibles': [('setTangentsLocked', 'tangentsLocked'),
                                   ('setWeightsLocked', 'weightsLocked'),
                                   ('setIsWeighted', 'isWeighted'),
                                   ('setPostInfinityType',
                                    'postInfinityType'),
                                   ('setInTangentType', 'inTangentType'),
                                   ('setPreInfinityType',
                                    'preInfinityType'),
                                   ('setTangent', 'getTangent'),
                                   ('setOutTangentType', 'outTangentType'),
                                   ('setValue', 'value'),
                                   ('setTime', 'time'),
                                   ('setUnitlessInput', 'unitlessInput'),
                                   ('setIsBreakdown', 'isBreakdown')],
                   'methods': {'addKey': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information. ',
                                                                  'type': 'MAnimCurveChange'},
                                                       'tangentInType': {'doc': 'In tangent type for the key ',
                                                                         'type': ('MFnAnimCurve',
                                                                                  'TangentType')},
                                                       'tangentOutType': {'doc': 'Out tangent type for the key ',
                                                                          'type': ('MFnAnimCurve',
                                                                                   'TangentType')},
                                                       'time': {'doc': 'Time at which the key is to be added ',
                                                                'type': 'MTime'},
                                                       'value': {'doc': 'Value to which the key is to be set ',
                                                                 'type': 'double'}},
                                           'args': [('time',
                                                     'MTime',
                                                     'in'),
                                                    ('value',
                                                     'double',
                                                     'in'),
                                                    ('tangentInType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('tangentOutType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('change',
                                                     'MAnimCurveChange',
                                                     'in')],
                                           'defaults': {'change': None,
                                                        'tangentInType': ('MFnAnimCurve',
                                                                          'TangentType',
                                                                          'kTangentGlobal'),
                                                        'tangentOutType': ('MFnAnimCurve',
                                                                           'TangentType',
                                                                           'kTangentGlobal')},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.',
                                           'inArgs': ['time',
                                                      'value',
                                                      'tangentInType',
                                                      'tangentOutType',
                                                      'change'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Index of the added key',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'change': ['*'],
                                                              'tangentInType': [],
                                                              'tangentOutType': [],
                                                              'time': ['const',
                                                                       '&'],
                                                              'value': []},
                                           'types': {'change': 'MAnimCurveChange',
                                                     'tangentInType': ('MFnAnimCurve',
                                                                       'TangentType'),
                                                     'tangentOutType': ('MFnAnimCurve',
                                                                        'TangentType'),
                                                     'time': 'MTime',
                                                     'value': 'double'}},
                                          {'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information. ',
                                                                  'type': 'MAnimCurveChange'},
                                                       'tangentInType': {'doc': 'In tangent type for the key ',
                                                                         'type': ('MFnAnimCurve',
                                                                                  'TangentType')},
                                                       'tangentOutType': {'doc': 'Out tangent type for the key ',
                                                                          'type': ('MFnAnimCurve',
                                                                                   'TangentType')},
                                                       'timeInput': {'doc': 'Time at which the key is to be added ',
                                                                     'type': 'MTime'},
                                                       'timeValue': {'doc': 'Value to which the key is to be set ',
                                                                     'type': 'MTime'}},
                                           'args': [('timeInput',
                                                     'MTime',
                                                     'in'),
                                                    ('timeValue',
                                                     'MTime',
                                                     'in'),
                                                    ('tangentInType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('tangentOutType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('change',
                                                     'MAnimCurveChange',
                                                     'in')],
                                           'defaults': {'change': None,
                                                        'tangentInType': ('MFnAnimCurve',
                                                                          'TangentType',
                                                                          'kTangentGlobal'),
                                                        'tangentOutType': ('MFnAnimCurve',
                                                                           'TangentType',
                                                                           'kTangentGlobal')},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new key with the given output time value and tangent types at the specified input time for curves of type kAnimCurveTT.',
                                           'inArgs': ['timeInput',
                                                      'timeValue',
                                                      'tangentInType',
                                                      'tangentOutType',
                                                      'change'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Index of the added key',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'change': ['*'],
                                                              'tangentInType': [],
                                                              'tangentOutType': [],
                                                              'timeInput': ['const',
                                                                            '&'],
                                                              'timeValue': ['const',
                                                                            '&']},
                                           'types': {'change': 'MAnimCurveChange',
                                                     'tangentInType': ('MFnAnimCurve',
                                                                       'TangentType'),
                                                     'tangentOutType': ('MFnAnimCurve',
                                                                        'TangentType'),
                                                     'timeInput': 'MTime',
                                                     'timeValue': 'MTime'}},
                                          {'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information. ',
                                                                  'type': 'MAnimCurveChange'},
                                                       'tangentInType': {'doc': 'In tangent type for the key ',
                                                                         'type': ('MFnAnimCurve',
                                                                                  'TangentType')},
                                                       'tangentOutType': {'doc': 'Out tangent type for the key ',
                                                                          'type': ('MFnAnimCurve',
                                                                                   'TangentType')},
                                                       'unitlessInput': {'doc': 'Unitless input at which the key is to be added ',
                                                                         'type': 'double'},
                                                       'value': {'doc': 'Value to which the key is to be set ',
                                                                 'type': 'double'}},
                                           'args': [('unitlessInput',
                                                     'double',
                                                     'in'),
                                                    ('value',
                                                     'double',
                                                     'in'),
                                                    ('tangentInType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('tangentOutType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('change',
                                                     'MAnimCurveChange',
                                                     'in')],
                                           'defaults': {'change': None,
                                                        'tangentInType': ('MFnAnimCurve',
                                                                          'TangentType',
                                                                          'kTangentGlobal'),
                                                        'tangentOutType': ('MFnAnimCurve',
                                                                           'TangentType',
                                                                           'kTangentGlobal')},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new key with the given value and tangent types at the specified unitless input for curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU.',
                                           'inArgs': ['unitlessInput',
                                                      'value',
                                                      'tangentInType',
                                                      'tangentOutType',
                                                      'change'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Index of added key',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'change': ['*'],
                                                              'tangentInType': [],
                                                              'tangentOutType': [],
                                                              'unitlessInput': [],
                                                              'value': []},
                                           'types': {'change': 'MAnimCurveChange',
                                                     'tangentInType': ('MFnAnimCurve',
                                                                       'TangentType'),
                                                     'tangentOutType': ('MFnAnimCurve',
                                                                        'TangentType'),
                                                     'unitlessInput': 'double',
                                                     'value': 'double'}},
                                          {'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information. ',
                                                                  'type': 'MAnimCurveChange'},
                                                       'tangentInType': {'doc': 'In tangent type for the key ',
                                                                         'type': ('MFnAnimCurve',
                                                                                  'TangentType')},
                                                       'tangentOutType': {'doc': 'Out tangent type for the key ',
                                                                          'type': ('MFnAnimCurve',
                                                                                   'TangentType')},
                                                       'timeValue': {'doc': 'Value to which the key is to be set ',
                                                                     'type': 'MTime'},
                                                       'unitlessInput': {'doc': 'Unitless input at which the key is to be added ',
                                                                         'type': 'double'}},
                                           'args': [('unitlessInput',
                                                     'double',
                                                     'in'),
                                                    ('timeValue',
                                                     'MTime',
                                                     'in'),
                                                    ('tangentInType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('tangentOutType',
                                                     ('MFnAnimCurve',
                                                      'TangentType'),
                                                     'in'),
                                                    ('change',
                                                     'MAnimCurveChange',
                                                     'in')],
                                           'defaults': {'change': None,
                                                        'tangentInType': ('MFnAnimCurve',
                                                                          'TangentType',
                                                                          'kTangentGlobal'),
                                                        'tangentOutType': ('MFnAnimCurve',
                                                                           'TangentType',
                                                                           'kTangentGlobal')},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new key with the given output time value and tangent types at the specified unitless input for curves of type kAnimCurveUT.',
                                           'inArgs': ['unitlessInput',
                                                      'timeValue',
                                                      'tangentInType',
                                                      'tangentOutType',
                                                      'change'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Index of added key',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'change': ['*'],
                                                              'tangentInType': [],
                                                              'tangentOutType': [],
                                                              'timeValue': ['const',
                                                                            '&'],
                                                              'unitlessInput': []},
                                           'types': {'change': 'MAnimCurveChange',
                                                     'tangentInType': ('MFnAnimCurve',
                                                                       'TangentType'),
                                                     'tangentOutType': ('MFnAnimCurve',
                                                                        'TangentType'),
                                                     'timeValue': 'MTime',
                                                     'unitlessInput': 'double'}}],
                               'addKeyframe': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                       'type': 'MAnimCurveChange'},
                                                            'time': {'doc': 'Time at which the key is to be added ',
                                                                     'type': 'MTime'},
                                                            'value': {'doc': 'Value to which the key is to be set ',
                                                                      'type': 'double'}},
                                                'args': [('time',
                                                          'MTime',
                                                          'in'),
                                                         ('value',
                                                          'double',
                                                          'in'),
                                                         ('change',
                                                          'MAnimCurveChange',
                                                          'in')],
                                                'defaults': {'change': None},
                                                'deprecated': False,
                                                'doc': '\r\nAdds a new key with the given value at the specified time.',
                                                'inArgs': ['time',
                                                           'value',
                                                           'change'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'change': ['*'],
                                                                   'time': ['const',
                                                                            '&'],
                                                                   'value': []},
                                                'types': {'change': 'MAnimCurveChange',
                                                          'time': 'MTime',
                                                          'value': 'double'}},
                                               {'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                       'type': 'MAnimCurveChange'},
                                                            'tangentInType': {'doc': 'In tangent type for the key ',
                                                                              'type': ('MFnAnimCurve',
                                                                                       'TangentType')},
                                                            'tangentOutType': {'doc': 'Out tangent type for the key ',
                                                                               'type': ('MFnAnimCurve',
                                                                                        'TangentType')},
                                                            'time': {'doc': 'Time at which the key is to be added ',
                                                                     'type': 'MTime'},
                                                            'value': {'doc': 'Value to which the key is to be set ',
                                                                      'type': 'double'}},
                                                'args': [('time',
                                                          'MTime',
                                                          'in'),
                                                         ('value',
                                                          'double',
                                                          'in'),
                                                         ('tangentInType',
                                                          ('MFnAnimCurve',
                                                           'TangentType'),
                                                          'in'),
                                                         ('tangentOutType',
                                                          ('MFnAnimCurve',
                                                           'TangentType'),
                                                          'in'),
                                                         ('change',
                                                          'MAnimCurveChange',
                                                          'in')],
                                                'defaults': {'change': None},
                                                'deprecated': False,
                                                'doc': '\r\nAdds a new key with the given value and tangent types at the specified time.',
                                                'inArgs': ['time',
                                                           'value',
                                                           'tangentInType',
                                                           'tangentOutType',
                                                           'change'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'change': ['*'],
                                                                   'tangentInType': [],
                                                                   'tangentOutType': [],
                                                                   'time': ['const',
                                                                            '&'],
                                                                   'value': []},
                                                'types': {'change': 'MAnimCurveChange',
                                                          'tangentInType': ('MFnAnimCurve',
                                                                            'TangentType'),
                                                          'tangentOutType': ('MFnAnimCurve',
                                                                             'TangentType'),
                                                          'time': 'MTime',
                                                          'value': 'double'}}],
                               'addKeys': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                   'type': 'MAnimCurveChange'},
                                                        'keepExistingKeys': {'doc': 'Specifies whether the new keys should be merged with existing keys, or if they should be cut prior to adding the new keys ',
                                                                             'type': 'bool'},
                                                        'tangentInType': {'doc': 'In tangent type for all the added keys ',
                                                                          'type': ('MFnAnimCurve',
                                                                                   'TangentType')},
                                                        'tangentOutType': {'doc': 'Out tangent type for all the added keys ',
                                                                           'type': ('MFnAnimCurve',
                                                                                    'TangentType')},
                                                        'timeArray': {'doc': 'Times at which keys are to be added ',
                                                                      'type': 'MTimeArray'},
                                                        'valueArray': {'doc': 'Values to which the keys is to be set ',
                                                                       'type': 'MDoubleArray'}},
                                            'args': [('timeArray',
                                                      'MTimeArray',
                                                      'in'),
                                                     ('valueArray',
                                                      'MDoubleArray',
                                                      'in'),
                                                     ('tangentInType',
                                                      ('MFnAnimCurve',
                                                       'TangentType'),
                                                      'in'),
                                                     ('tangentOutType',
                                                      ('MFnAnimCurve',
                                                       'TangentType'),
                                                      'in'),
                                                     ('keepExistingKeys',
                                                      'bool',
                                                      'in'),
                                                     ('change',
                                                      'MAnimCurveChange',
                                                      'in')],
                                            'defaults': {'change': None,
                                                         'keepExistingKeys': False,
                                                         'tangentInType': ('MFnAnimCurve',
                                                                           'TangentType',
                                                                           'kTangentGlobal'),
                                                         'tangentOutType': ('MFnAnimCurve',
                                                                            'TangentType',
                                                                            'kTangentGlobal')},
                                            'deprecated': False,
                                            'doc': '\r\nAdd a set of new keys with the given corresponding values and tangent types at the specified times. This method only works for Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.',
                                            'inArgs': ['timeArray',
                                                       'valueArray',
                                                       'tangentInType',
                                                       'tangentOutType',
                                                       'keepExistingKeys',
                                                       'change'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'change': ['*'],
                                                               'keepExistingKeys': [],
                                                               'tangentInType': [],
                                                               'tangentOutType': [],
                                                               'timeArray': ['*'],
                                                               'valueArray': ['*']},
                                            'types': {'change': 'MAnimCurveChange',
                                                      'keepExistingKeys': 'bool',
                                                      'tangentInType': ('MFnAnimCurve',
                                                                        'TangentType'),
                                                      'tangentOutType': ('MFnAnimCurve',
                                                                         'TangentType'),
                                                      'timeArray': 'MTimeArray',
                                                      'valueArray': 'MDoubleArray'}}],
                               'addKeysWithTangents': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                               'type': 'MAnimCurveChange'},
                                                                    'convertUnits': {'doc': 'Whether to convert to UI units before setting ',
                                                                                     'type': 'bool'},
                                                                    'keepExistingKeys': {'doc': 'Specifies whether the new keys should be merged with existing keys, or if they should be cut prior to adding the new keys ',
                                                                                         'type': 'bool'},
                                                                    'tangentInType': {'doc': 'In tangent type for all the added keys ',
                                                                                      'type': ('MFnAnimCurve',
                                                                                               'TangentType')},
                                                                    'tangentInTypeArray': {'doc': 'In tangent types for individual added keys ',
                                                                                           'type': 'MIntArray'},
                                                                    'tangentInXArray': {'doc': 'Absolute x value of the slope of in tangent ',
                                                                                        'type': 'MDoubleArray'},
                                                                    'tangentInYArray': {'doc': 'Absolute y value of the slope of in tangent ',
                                                                                        'type': 'MDoubleArray'},
                                                                    'tangentOutType': {'doc': 'Out tangent type for all the added keys ',
                                                                                       'type': ('MFnAnimCurve',
                                                                                                'TangentType')},
                                                                    'tangentOutTypeArray': {'doc': 'Out tangent types for individual added keys ',
                                                                                            'type': 'MIntArray'},
                                                                    'tangentOutXArray': {'doc': 'Absolute x value of the slope of out tangent ',
                                                                                         'type': 'MDoubleArray'},
                                                                    'tangentOutYArray': {'doc': 'Absolute y value of the slope of out tangent ',
                                                                                         'type': 'MDoubleArray'},
                                                                    'tangentsLockedArray': {'doc': 'Lock or unlock the tangents ',
                                                                                            'type': 'MIntArray'},
                                                                    'timeArray': {'doc': 'Times at which keys are to be added ',
                                                                                  'type': 'MTimeArray'},
                                                                    'valueArray': {'doc': 'Values to which the keys is to be set ',
                                                                                   'type': 'MDoubleArray'},
                                                                    'weightsLockedArray': {'doc': 'Lock or unlock the weights ',
                                                                                           'type': 'MIntArray'}},
                                                        'args': [('timeArray',
                                                                  'MTimeArray',
                                                                  'in'),
                                                                 ('valueArray',
                                                                  'MDoubleArray',
                                                                  'in'),
                                                                 ('tangentInType',
                                                                  ('MFnAnimCurve',
                                                                   'TangentType'),
                                                                  'in'),
                                                                 ('tangentOutType',
                                                                  ('MFnAnimCurve',
                                                                   'TangentType'),
                                                                  'in'),
                                                                 ('tangentInTypeArray',
                                                                  'MIntArray',
                                                                  'in'),
                                                                 ('tangentOutTypeArray',
                                                                  'MIntArray',
                                                                  'in'),
                                                                 ('tangentInXArray',
                                                                  'MDoubleArray',
                                                                  'in'),
                                                                 ('tangentInYArray',
                                                                  'MDoubleArray',
                                                                  'in'),
                                                                 ('tangentOutXArray',
                                                                  'MDoubleArray',
                                                                  'in'),
                                                                 ('tangentOutYArray',
                                                                  'MDoubleArray',
                                                                  'in'),
                                                                 ('tangentsLockedArray',
                                                                  'MIntArray',
                                                                  'in'),
                                                                 ('weightsLockedArray',
                                                                  'MIntArray',
                                                                  'in'),
                                                                 ('convertUnits',
                                                                  'bool',
                                                                  'in'),
                                                                 ('keepExistingKeys',
                                                                  'bool',
                                                                  'in'),
                                                                 ('change',
                                                                  'MAnimCurveChange',
                                                                  'in')],
                                                        'defaults': {'change': None,
                                                                     'convertUnits': True,
                                                                     'keepExistingKeys': False,
                                                                     'tangentInType': ('MFnAnimCurve',
                                                                                       'TangentType',
                                                                                       'kTangentGlobal'),
                                                                     'tangentInTypeArray': None,
                                                                     'tangentInXArray': None,
                                                                     'tangentInYArray': None,
                                                                     'tangentOutType': ('MFnAnimCurve',
                                                                                        'TangentType',
                                                                                        'kTangentGlobal'),
                                                                     'tangentOutTypeArray': None,
                                                                     'tangentOutXArray': None,
                                                                     'tangentOutYArray': None,
                                                                     'tangentsLockedArray': None,
                                                                     'weightsLockedArray': None},
                                                        'deprecated': False,
                                                        'doc': '\r\nAdd a set of new keys with the given corresponding values and tangent types at the specified times. This method only works for Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.',
                                                        'inArgs': ['timeArray',
                                                                   'valueArray',
                                                                   'tangentInType',
                                                                   'tangentOutType',
                                                                   'tangentInTypeArray',
                                                                   'tangentOutTypeArray',
                                                                   'tangentInXArray',
                                                                   'tangentInYArray',
                                                                   'tangentOutXArray',
                                                                   'tangentOutYArray',
                                                                   'tangentsLockedArray',
                                                                   'weightsLockedArray',
                                                                   'convertUnits',
                                                                   'keepExistingKeys',
                                                                   'change'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'change': ['*'],
                                                                           'convertUnits': [],
                                                                           'keepExistingKeys': [],
                                                                           'tangentInType': [],
                                                                           'tangentInTypeArray': ['*'],
                                                                           'tangentInXArray': ['*'],
                                                                           'tangentInYArray': ['*'],
                                                                           'tangentOutType': [],
                                                                           'tangentOutTypeArray': ['*'],
                                                                           'tangentOutXArray': ['*'],
                                                                           'tangentOutYArray': ['*'],
                                                                           'tangentsLockedArray': ['*'],
                                                                           'timeArray': ['*'],
                                                                           'valueArray': ['*'],
                                                                           'weightsLockedArray': ['*']},
                                                        'types': {'change': 'MAnimCurveChange',
                                                                  'convertUnits': 'bool',
                                                                  'keepExistingKeys': 'bool',
                                                                  'tangentInType': ('MFnAnimCurve',
                                                                                    'TangentType'),
                                                                  'tangentInTypeArray': 'MIntArray',
                                                                  'tangentInXArray': 'MDoubleArray',
                                                                  'tangentInYArray': 'MDoubleArray',
                                                                  'tangentOutType': ('MFnAnimCurve',
                                                                                     'TangentType'),
                                                                  'tangentOutTypeArray': 'MIntArray',
                                                                  'tangentOutXArray': 'MDoubleArray',
                                                                  'tangentOutYArray': 'MDoubleArray',
                                                                  'tangentsLockedArray': 'MIntArray',
                                                                  'timeArray': 'MTimeArray',
                                                                  'valueArray': 'MDoubleArray',
                                                                  'weightsLockedArray': 'MIntArray'}}],
                               'animCurveType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the animCurve type',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The animCurve type.',
                                                                 'qualifiers': [],
                                                                 'type': ('MFnAnimCurve',
                                                                          'AnimCurveType')},
                                                  'returnType': ('MFnAnimCurve',
                                                                 'AnimCurveType'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClass name. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'create': [{'argInfo': {'attribute': {'doc': 'Attribute on the given node to which the output of the new Anim Curve Node is to be connected ',
                                                                     'type': 'MObject'},
                                                       'modifier': {'doc': 'Modifier to be used so undo capability is retained by caller ',
                                                                    'type': 'MDGModifier'},
                                                       'node': {'doc': 'DG Node to which the output of the new Anim Curve Node is to be connected ',
                                                                'type': 'MObject'}},
                                           'args': [('node',
                                                     'MObject',
                                                     'in'),
                                                    ('attribute',
                                                     'MObject',
                                                     'in'),
                                                    ('modifier',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'modifier': None},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new Anim Curve Node, attaches the Function Set to the new Node (detaching from the current Node) and connects the output of the new Anim Curve Node to an animatable Attribute on another DG Node. This method will fail if the target Attribute is not animatable, or if a connection to the target Attribute already exists.',
                                           'inArgs': ['node',
                                                      'attribute',
                                                      'modifier'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The new Anim Curve Node',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'attribute': ['const',
                                                                            '&'],
                                                              'modifier': ['*'],
                                                              'node': ['const',
                                                                       '&']},
                                           'types': {'attribute': 'MObject',
                                                     'modifier': 'MDGModifier',
                                                     'node': 'MObject'}},
                                          {'argInfo': {'animCurveType': {'doc': 'The animCurve Type to be created ',
                                                                         'type': ('MFnAnimCurve',
                                                                                  'AnimCurveType')},
                                                       'attribute': {'doc': 'Attribute on the given node to which the output of the new Anim Curve Node is to be connected ',
                                                                     'type': 'MObject'},
                                                       'modifier': {'doc': 'Modifier to be used so undo capability is retained by caller ',
                                                                    'type': 'MDGModifier'},
                                                       'node': {'doc': 'DG Node to which the output of the new Anim Curve Node is to be connected ',
                                                                'type': 'MObject'}},
                                           'args': [('node',
                                                     'MObject',
                                                     'in'),
                                                    ('attribute',
                                                     'MObject',
                                                     'in'),
                                                    ('animCurveType',
                                                     ('MFnAnimCurve',
                                                      'AnimCurveType'),
                                                     'in'),
                                                    ('modifier',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'modifier': None},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new Anim Curve Node, attaches the Function Set to the new Node (detaching from the current Node) and connects the output of the new Anim Curve Node to an animatable Attribute on another DG Node. This method will fail if the target Attribute is not animatable, or if a connection to the target Attribute already exists.',
                                           'inArgs': ['node',
                                                      'attribute',
                                                      'animCurveType',
                                                      'modifier'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The new Anim Curve Node',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'animCurveType': [],
                                                              'attribute': ['const',
                                                                            '&'],
                                                              'modifier': ['*'],
                                                              'node': ['const',
                                                                       '&']},
                                           'types': {'animCurveType': ('MFnAnimCurve',
                                                                       'AnimCurveType'),
                                                     'attribute': 'MObject',
                                                     'modifier': 'MDGModifier',
                                                     'node': 'MObject'}},
                                          {'argInfo': {'modifier': {'doc': 'Modifier to be used so undo capability is retained by caller ',
                                                                    'type': 'MDGModifier'},
                                                       'plug': {'doc': 'Plug to which the output of the new Anim Curve Node is to be connected ',
                                                                'type': 'MPlug'}},
                                           'args': [('plug',
                                                     'MPlug',
                                                     'in'),
                                                    ('modifier',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'modifier': None},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new Anim Curve Node, attaches the Function Set to the new Node (detaching from the current Node) and connects the output of the new Anim Curve Node to the Plug on an animatable Attribute on another DG Node. This method will fail if the target Attribute is not animatable, or if a connection to the target Attribute already exists.',
                                           'inArgs': ['plug', 'modifier'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The new Anim Curve Node',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'modifier': ['*'],
                                                              'plug': ['const',
                                                                       '&']},
                                           'types': {'modifier': 'MDGModifier',
                                                     'plug': 'MPlug'}},
                                          {'argInfo': {'animCurveType': {'doc': 'The animCurve type to be created ',
                                                                         'type': ('MFnAnimCurve',
                                                                                  'AnimCurveType')},
                                                       'modifier': {'doc': 'Modifier to be used so undo capability is retained by caller ',
                                                                    'type': 'MDGModifier'},
                                                       'plug': {'doc': 'Plug to which the output of the new Anim Curve Node is to be connected ',
                                                                'type': 'MPlug'}},
                                           'args': [('plug',
                                                     'MPlug',
                                                     'in'),
                                                    ('animCurveType',
                                                     ('MFnAnimCurve',
                                                      'AnimCurveType'),
                                                     'in'),
                                                    ('modifier',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'modifier': None},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new Anim Curve Node, attaches the Function Set to the new Node (detaching from the current Node) and connects the output of the new Anim Curve Node to the Plug on an animatable Attribute on another DG Node. This method will fail if the target Attribute is not animatable, or if a connection to the target Attribute already exists.',
                                           'inArgs': ['plug',
                                                      'animCurveType',
                                                      'modifier'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The new Anim Curve Node',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'animCurveType': [],
                                                              'modifier': ['*'],
                                                              'plug': ['const',
                                                                       '&']},
                                           'types': {'animCurveType': ('MFnAnimCurve',
                                                                       'AnimCurveType'),
                                                     'modifier': 'MDGModifier',
                                                     'plug': 'MPlug'}},
                                          {'argInfo': {'animCurveType': {'doc': 'The type of Anim Curve to be created ',
                                                                         'type': ('MFnAnimCurve',
                                                                                  'AnimCurveType')},
                                                       'modifier': {'doc': 'Modifier to be used so undo capability is retained by caller ',
                                                                    'type': 'MDGModifier'}},
                                           'args': [('animCurveType',
                                                     ('MFnAnimCurve',
                                                      'AnimCurveType'),
                                                     'in'),
                                                    ('modifier',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'modifier': None},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new Anim Curve Node, attaches the Function Set to the new Node (detaching from the current Node) but does not attempt to connect the new Anim Curve Node.',
                                           'inArgs': ['animCurveType',
                                                      'modifier'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The new Anim Curve Node',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'animCurveType': [],
                                                              'modifier': ['*']},
                                           'types': {'animCurveType': ('MFnAnimCurve',
                                                                       'AnimCurveType'),
                                                     'modifier': 'MDGModifier'}}],
                               'evaluate': [{'argInfo': {'atTime': {'doc': 'Time at which the Anim Curve is to be evaluated ',
                                                                    'type': 'MTime'}},
                                             'args': [('atTime',
                                                       'MTime',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.',
                                             'inArgs': ['atTime'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Interpolated value of Anim Curve at specified time',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'atTime': ['const',
                                                                           '&']},
                                             'types': {'atTime': 'MTime'}},
                                            {'argInfo': {'atTime': {'doc': 'Time at which the Anim Curve is to be evaluated ',
                                                                    'type': 'MTime'},
                                                         'value': {'doc': 'Interpolated value of Anim Curve at specified time',
                                                                   'type': 'double'}},
                                             'args': [('atTime',
                                                       'MTime',
                                                       'in'),
                                                      ('value',
                                                       'double',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.',
                                             'inArgs': ['atTime'],
                                             'outArgs': ['value'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'atTime': ['const',
                                                                           '&'],
                                                                'value': ['&']},
                                             'types': {'atTime': 'MTime',
                                                       'value': 'double'}},
                                            {'argInfo': {'atTime': {'doc': 'Time at which the Anim Curve is to be evaluated ',
                                                                    'type': 'MTime'},
                                                         'timeValue': {'doc': 'Interpolated output time of Anim Curve at specified time',
                                                                       'type': 'MTime'}},
                                             'args': [('atTime',
                                                       'MTime',
                                                       'in'),
                                                      ('timeValue',
                                                       'MTime',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines the interpolated output value of Anim Curves of type kAnimCurveTT at the specified time.',
                                             'inArgs': ['atTime'],
                                             'outArgs': ['timeValue'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'atTime': ['const',
                                                                           '&'],
                                                                'timeValue': ['&']},
                                             'types': {'atTime': 'MTime',
                                                       'timeValue': 'MTime'}},
                                            {'argInfo': {'atUnitlessInput': {'doc': 'Input value at which the Anim Curve is to be evaluated ',
                                                                             'type': 'double'},
                                                         'value': {'doc': 'Interpolated output value of Anim Curve at specified input value',
                                                                   'type': 'double'}},
                                             'args': [('atUnitlessInput',
                                                       'double',
                                                       'out'),
                                                      ('value',
                                                       'double',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines the interpolated output value of Anim Curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU at the specified unitless input.',
                                             'inArgs': [],
                                             'outArgs': ['atUnitlessInput',
                                                         'value'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'atUnitlessInput': ['const',
                                                                                    '&'],
                                                                'value': ['&']},
                                             'types': {'atUnitlessInput': 'double',
                                                       'value': 'double'}},
                                            {'argInfo': {'atUnitlessInput': {'doc': 'Input value at which the Anim Curve is to be evaluated ',
                                                                             'type': 'double'},
                                                         'timeValue': {'doc': 'Interpolated output time of Anim Curve at specified time',
                                                                       'type': 'MTime'}},
                                             'args': [('atUnitlessInput',
                                                       'double',
                                                       'out'),
                                                      ('timeValue',
                                                       'MTime',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines the interpolated output value of Anim Curves of type kAnimCurveUT at the specified unitless input.',
                                             'inArgs': [],
                                             'outArgs': ['atUnitlessInput',
                                                         'timeValue'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'atUnitlessInput': ['const',
                                                                                    '&'],
                                                                'timeValue': ['&']},
                                             'types': {'atUnitlessInput': 'double',
                                                       'timeValue': 'MTime'}}],
                               'find': [{'argInfo': {'index': {'doc': 'Key index at the specified time (implicit return) ',
                                                               'type': 'uint'},
                                                     'time': {'doc': 'Time for which a key index is required ',
                                                              'type': 'MTime'}},
                                         'args': [('time',
                                                   'MTime',
                                                   'in'),
                                                  ('index',
                                                   'uint',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nDetermines the index of the key which is set at the specified time.',
                                         'inArgs': ['time'],
                                         'outArgs': ['index'],
                                         'returnInfo': {'doc': 'Boolean value: true if the index is found false otherwise',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': ['unsigned',
                                                                      '&'],
                                                            'time': ['const',
                                                                     '&']},
                                         'types': {'index': 'uint',
                                                   'time': 'MTime'}},
                                        {'argInfo': {'index': {'doc': 'Key index at the specified time (implicit return) ',
                                                               'type': 'uint'},
                                                     'unitlessInput': {'doc': 'Value for which a key index is required ',
                                                                       'type': 'double'}},
                                         'args': [('unitlessInput',
                                                   'double',
                                                   'in'),
                                                  ('index',
                                                   'uint',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nDetermines the index of the key which is set at the specified unitless input value.',
                                         'inArgs': ['unitlessInput'],
                                         'outArgs': ['index'],
                                         'returnInfo': {'doc': 'Boolean value: true if the index is found false otherwise',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': ['unsigned',
                                                                      '&'],
                                                            'unitlessInput': []},
                                         'types': {'index': 'uint',
                                                   'unitlessInput': 'double'}}],
                               'findClosest': [{'argInfo': {'time': {'doc': 'Time for which a key index is required ',
                                                                     'type': 'MTime'}},
                                                'args': [('time',
                                                          'MTime',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines the index of the key which is set at the time closest to the specified time.',
                                                'inArgs': ['time'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Key index closest to the specified time',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'time': ['const',
                                                                            '&']},
                                                'types': {'time': 'MTime'}},
                                               {'argInfo': {'unitlessInput': {'doc': 'Input value for which a key index is required ',
                                                                              'type': 'double'}},
                                                'args': [('unitlessInput',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines the index of the key which is set at the time closest to the specified unitless input value.',
                                                'inArgs': ['unitlessInput'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Key index closest to the specified time',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'unitlessInput': []},
                                                'types': {'unitlessInput': 'double'}}],
                               'getTangent': [{'argInfo': {'inTangent': {'doc': 'If true, the in-tangent is returned, else, the out-tangent is returned',
                                                                         'type': 'bool'},
                                                           'index': {'doc': 'Index of the key for which the tangent x,y value is required ',
                                                                     'type': 'uint'},
                                                           'x': {'doc': 'The x value of the slope of the tangent in seconds ',
                                                                 'type': ('MFnAnimCurve',
                                                                          'TangentValue')},
                                                           'y': {'doc': 'Absolute y value of the slope of the tangent ',
                                                                 'type': ('MFnAnimCurve',
                                                                          'TangentValue')}},
                                               'args': [('index',
                                                         'uint',
                                                         'in'),
                                                        ('x',
                                                         ('MFnAnimCurve',
                                                          'TangentValue'),
                                                         'out'),
                                                        ('y',
                                                         ('MFnAnimCurve',
                                                          'TangentValue'),
                                                         'out'),
                                                        ('inTangent',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nDetermines the x,y value representing the vector of the in- or out-tangent (depending on the value of the inTangent parameter) to the curve for the key at the specified index. The values returned will be in Maya's internal units (seconds for time, centimeters for linear, radians for angles). The following examples demonstrates how to convert from internal units of seconds into the current user time unit.",
                                               'inArgs': ['index',
                                                          'inTangent'],
                                               'inverse': ('setTangent',
                                                           False),
                                               'outArgs': ['x', 'y'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'inTangent': [],
                                                                  'index': ['unsigned'],
                                                                  'x': ['&'],
                                                                  'y': ['&']},
                                               'types': {'inTangent': 'bool',
                                                         'index': 'uint',
                                                         'x': ('MFnAnimCurve',
                                                               'TangentValue'),
                                                         'y': ('MFnAnimCurve',
                                                               'TangentValue')}},
                                              {'argInfo': {'angle': {'doc': 'The tangent angle ',
                                                                     'type': 'MAngle'},
                                                           'inTangent': {'doc': 'If true, the inTangent is returned, else, the outTangent is returned',
                                                                         'type': 'bool'},
                                                           'index': {'doc': 'Index of the key for which the tangent x,y value is required ',
                                                                     'type': 'uint'},
                                                           'weight': {'doc': 'The tangent weight ',
                                                                      'type': 'double'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in'),
                                                        ('angle',
                                                         'MAngle',
                                                         'out'),
                                                        ('weight',
                                                         'double',
                                                         'out'),
                                                        ('inTangent',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermines the angle and weight of the in- or out-tangent to the curve for the key at the specified index.',
                                               'inArgs': ['index',
                                                          'inTangent'],
                                               'inverse': ('setTangent',
                                                           False),
                                               'outArgs': ['angle',
                                                           'weight'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'angle': ['&'],
                                                                  'inTangent': [],
                                                                  'index': ['unsigned'],
                                                                  'weight': ['&']},
                                               'types': {'angle': 'MAngle',
                                                         'inTangent': 'bool',
                                                         'index': 'uint',
                                                         'weight': 'double'}}],
                               'inTangentType': [{'argInfo': {'index': {'doc': 'Index of the key for which the tangent type is required ',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermines the type of the tangent to the curve entering the current key.',
                                                  'inArgs': ['index'],
                                                  'inverse': ('setInTangentType',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Type of the tangent',
                                                                 'qualifiers': [],
                                                                 'type': ('MFnAnimCurve',
                                                                          'TangentType')},
                                                  'returnType': ('MFnAnimCurve',
                                                                 'TangentType'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}],
                               'isBreakdown': [{'argInfo': {'index': {'doc': "The key's index ",
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines whether or not a key is a breakdown.',
                                                'inArgs': ['index'],
                                                'inverse': ('setIsBreakdown',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Boolean value: true if the key is a breakdown, false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'isStatic': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines whether or not the animCurve is static. The animCurve is considered to be static if it would return the same value regardless of the evaluation time. This basically means that the values of all the keys are the same and the y component of all the tangents is 0.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Boolean value: true if the curve is static, false otherwise',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'isTimeInput': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines the input type of the animCurve.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Boolean value: true if the curve takes time as input false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                               'isUnitlessInput': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDetermines the input type of the animCurve.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Boolean value: true if the curve takes a unitless value as input, false otherwise.',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                               'isWeighted': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermines whether or not the curve has weighted tangents.',
                                               'inArgs': [],
                                               'inverse': ('setIsWeighted',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if the curve has weighted tangents, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                               'numKeyframes': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': True,
                                                 'doc': '\n This method is obsolete. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Number of keys on the Anim Curve Node ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                               'numKeys': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermines the number of keys on the Anim Curve Node.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Number of keys on the Anim Curve Node',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                               'outTangentType': [{'argInfo': {'index': {'doc': 'Index of the key for which the tangent type is required ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines the type of the tangent to the curve leaving the current key.',
                                                   'inArgs': ['index'],
                                                   'inverse': ('setOutTangentType',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Type of the tangent',
                                                                  'qualifiers': [],
                                                                  'type': ('MFnAnimCurve',
                                                                           'TangentType')},
                                                   'returnType': ('MFnAnimCurve',
                                                                  'TangentType'),
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                               'postInfinityType': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nDetermines the behaviour of the curve for the range occurring after the last key.',
                                                     'inArgs': [],
                                                     'inverse': ('setPostInfinityType',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The current postInfinityType for the curve',
                                                                    'qualifiers': [],
                                                                    'type': ('MFnAnimCurve',
                                                                             'InfinityType')},
                                                     'returnType': ('MFnAnimCurve',
                                                                    'InfinityType'),
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                               'preInfinityType': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDetermines the behaviour of the curve for the range occurring before the first key.',
                                                    'inArgs': [],
                                                    'inverse': ('setPreInfinityType',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The current preInfinityType for the curve',
                                                                   'qualifiers': [],
                                                                   'type': ('MFnAnimCurve',
                                                                            'InfinityType')},
                                                    'returnType': ('MFnAnimCurve',
                                                                   'InfinityType'),
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                               'remove': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                  'type': 'MAnimCurveChange'},
                                                       'index': {'doc': 'Index of the key to be removed ',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in'),
                                                    ('change',
                                                     'MAnimCurveChange',
                                                     'in')],
                                           'defaults': {'change': None},
                                           'deprecated': False,
                                           'doc': '\r\nRemoves the key at the specified index.',
                                           'inArgs': ['index', 'change'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'change': ['*'],
                                                              'index': ['unsigned']},
                                           'types': {'change': 'MAnimCurveChange',
                                                     'index': 'uint'}}],
                               'setAngle': [{'argInfo': {'angle': {'doc': "The new in- or out-angle for the key's tangent ",
                                                                   'type': 'MAngle'},
                                                         'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                    'type': 'MAnimCurveChange'},
                                                         'inTangent': {'doc': 'If true, set the in-tangent, else out-tangent ',
                                                                       'type': 'bool'},
                                                         'index': {'doc': 'Index of the key ',
                                                                   'type': 'uint'}},
                                             'args': [('index',
                                                       'uint',
                                                       'in'),
                                                      ('angle',
                                                       'MAngle',
                                                       'in'),
                                                      ('inTangent',
                                                       'bool',
                                                       'in'),
                                                      ('change',
                                                       'MAnimCurveChange',
                                                       'in')],
                                             'defaults': {'change': None},
                                             'deprecated': False,
                                             'doc': '\r\nSet the in- or out-angle of the tangent for the key at the given index',
                                             'inArgs': ['index',
                                                        'angle',
                                                        'inTangent',
                                                        'change'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'angle': ['const',
                                                                          '&'],
                                                                'change': ['*'],
                                                                'inTangent': [],
                                                                'index': ['unsigned']},
                                             'types': {'angle': 'MAngle',
                                                       'change': 'MAnimCurveChange',
                                                       'inTangent': 'bool',
                                                       'index': 'uint'}}],
                               'setInTangentType': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                            'type': 'MAnimCurveChange'},
                                                                 'index': {'doc': 'Index of the key for which the tangent type is to be set ',
                                                                           'type': 'uint'},
                                                                 'tangentType': {'doc': 'Type to which the tangent is to be set ',
                                                                                 'type': ('MFnAnimCurve',
                                                                                          'TangentType')}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('tangentType',
                                                               ('MFnAnimCurve',
                                                                'TangentType'),
                                                               'in'),
                                                              ('change',
                                                               'MAnimCurveChange',
                                                               'in')],
                                                     'defaults': {'change': None},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the type of the tangent to the curve entering the key at the specified index.',
                                                     'inArgs': ['index',
                                                                'tangentType',
                                                                'change'],
                                                     'inverse': ('inTangentType',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'change': ['*'],
                                                                        'index': ['unsigned'],
                                                                        'tangentType': []},
                                                     'types': {'change': 'MAnimCurveChange',
                                                               'index': 'uint',
                                                               'tangentType': ('MFnAnimCurve',
                                                                               'TangentType')}}],
                               'setIsBreakdown': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                          'type': 'MAnimCurveChange'},
                                                               'index': {'doc': 'Index of the key whose breakdown state is to be modified ',
                                                                         'type': 'uint'},
                                                               'isBreakdown': {'doc': 'The new breakdown state for the key. ',
                                                                               'type': 'bool'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in'),
                                                            ('isBreakdown',
                                                             'bool',
                                                             'in'),
                                                            ('change',
                                                             'MAnimCurveChange',
                                                             'in')],
                                                   'defaults': {'change': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the breakdown state of a key at a given index.',
                                                   'inArgs': ['index',
                                                              'isBreakdown',
                                                              'change'],
                                                   'inverse': ('isBreakdown',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'change': ['*'],
                                                                      'index': ['unsigned'],
                                                                      'isBreakdown': []},
                                                   'types': {'change': 'MAnimCurveChange',
                                                             'index': 'uint',
                                                             'isBreakdown': 'bool'}}],
                               'setIsWeighted': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                         'type': 'MAnimCurveChange'},
                                                              'isWeighted': {'doc': 'Whether or not the curve should have weighted tangents ',
                                                                             'type': 'bool'}},
                                                  'args': [('isWeighted',
                                                            'bool',
                                                            'in'),
                                                           ('change',
                                                            'MAnimCurveChange',
                                                            'in')],
                                                  'defaults': {'change': None},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets whether or not the curve has weighted tangents.',
                                                  'inArgs': ['isWeighted',
                                                             'change'],
                                                  'inverse': ('isWeighted',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'change': ['*'],
                                                                     'isWeighted': []},
                                                  'types': {'change': 'MAnimCurveChange',
                                                            'isWeighted': 'bool'}}],
                               'setOutTangentType': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                             'type': 'MAnimCurveChange'},
                                                                  'index': {'doc': 'Index of the key for which the tangent type is to be set ',
                                                                            'type': 'uint'},
                                                                  'tangentType': {'doc': 'Type to which the tangent is to be set ',
                                                                                  'type': ('MFnAnimCurve',
                                                                                           'TangentType')}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in'),
                                                               ('tangentType',
                                                                ('MFnAnimCurve',
                                                                 'TangentType'),
                                                                'in'),
                                                               ('change',
                                                                'MAnimCurveChange',
                                                                'in')],
                                                      'defaults': {'change': None},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the type of the tangent to the curve leaving the key at the specified index.',
                                                      'inArgs': ['index',
                                                                 'tangentType',
                                                                 'change'],
                                                      'inverse': ('outTangentType',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'change': ['*'],
                                                                         'index': ['unsigned'],
                                                                         'tangentType': []},
                                                      'types': {'change': 'MAnimCurveChange',
                                                                'index': 'uint',
                                                                'tangentType': ('MFnAnimCurve',
                                                                                'TangentType')}}],
                               'setPostInfinityType': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                               'type': 'MAnimCurveChange'},
                                                                    'infinityType': {'doc': 'The infinity type to be set. ',
                                                                                     'type': ('MFnAnimCurve',
                                                                                              'InfinityType')}},
                                                        'args': [('infinityType',
                                                                  ('MFnAnimCurve',
                                                                   'InfinityType'),
                                                                  'in'),
                                                                 ('change',
                                                                  'MAnimCurveChange',
                                                                  'in')],
                                                        'defaults': {'change': None},
                                                        'deprecated': False,
                                                        'doc': '\r\nSet the behaviour of the curve for the range occurring after the last key.',
                                                        'inArgs': ['infinityType',
                                                                   'change'],
                                                        'inverse': ('postInfinityType',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'change': ['*'],
                                                                           'infinityType': []},
                                                        'types': {'change': 'MAnimCurveChange',
                                                                  'infinityType': ('MFnAnimCurve',
                                                                                   'InfinityType')}}],
                               'setPreInfinityType': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                              'type': 'MAnimCurveChange'},
                                                                   'infinityType': {'doc': 'The infinity type to be set. ',
                                                                                    'type': ('MFnAnimCurve',
                                                                                             'InfinityType')}},
                                                       'args': [('infinityType',
                                                                 ('MFnAnimCurve',
                                                                  'InfinityType'),
                                                                 'in'),
                                                                ('change',
                                                                 'MAnimCurveChange',
                                                                 'in')],
                                                       'defaults': {'change': None},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet the behaviour of the curve for the range occurring before the first key.',
                                                       'inArgs': ['infinityType',
                                                                  'change'],
                                                       'inverse': ('preInfinityType',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'change': ['*'],
                                                                          'infinityType': []},
                                                       'types': {'change': 'MAnimCurveChange',
                                                                 'infinityType': ('MFnAnimCurve',
                                                                                  'InfinityType')}}],
                               'setTangent': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information. ',
                                                                      'type': 'MAnimCurveChange'},
                                                           'convertUnits': {'doc': 'Whether to convert to UI units before setting',
                                                                            'type': 'bool'},
                                                           'inTangent': {'doc': 'If true, the inTangent is modified, else, the outTangent is modified ',
                                                                         'type': 'bool'},
                                                           'index': {'doc': 'Index of the key for which the tangent type is to be set ',
                                                                     'type': 'uint'},
                                                           'x': {'doc': 'Absolute x value of the slope of the tangent ',
                                                                 'type': ('MFnAnimCurve',
                                                                          'TangentValue')},
                                                           'y': {'doc': 'Absolute y value of the slope of the tangent ',
                                                                 'type': ('MFnAnimCurve',
                                                                          'TangentValue')}},
                                               'args': [('index',
                                                         'uint',
                                                         'in'),
                                                        ('x',
                                                         ('MFnAnimCurve',
                                                          'TangentValue'),
                                                         'in'),
                                                        ('y',
                                                         ('MFnAnimCurve',
                                                          'TangentValue'),
                                                         'in'),
                                                        ('inTangent',
                                                         'bool',
                                                         'in'),
                                                        ('change',
                                                         'MAnimCurveChange',
                                                         'in'),
                                                        ('convertUnits',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'change': None,
                                                            'convertUnits': True},
                                               'deprecated': False,
                                               'doc': '\r\nSets the tangent for the key at the specified index. If convertUnits is true (the default) the x value will be scaled by the current UI time units and the y value will be scaled by the relevant UI units for the output type of the animation curve (i.e. linear units for a curve that outputs linear data, and so on).',
                                               'inArgs': ['index',
                                                          'x',
                                                          'y',
                                                          'inTangent',
                                                          'change',
                                                          'convertUnits'],
                                               'inverse': ('getTangent',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'change': ['*'],
                                                                  'convertUnits': [],
                                                                  'inTangent': [],
                                                                  'index': ['unsigned'],
                                                                  'x': [],
                                                                  'y': []},
                                               'types': {'change': 'MAnimCurveChange',
                                                         'convertUnits': 'bool',
                                                         'inTangent': 'bool',
                                                         'index': 'uint',
                                                         'x': ('MFnAnimCurve',
                                                               'TangentValue'),
                                                         'y': ('MFnAnimCurve',
                                                               'TangentValue')}},
                                              {'argInfo': {'angle': {'doc': 'The angle to set the tangent ',
                                                                     'type': 'MAngle'},
                                                           'change': {'doc': 'Optional cache to store undo/redo information. ',
                                                                      'type': 'MAnimCurveChange'},
                                                           'convertUnits': {'doc': 'Whether to convert to UI units before setting',
                                                                            'type': 'bool'},
                                                           'inTangent': {'doc': 'If true, the inTangent is modified, else, the outTangent is modified ',
                                                                         'type': 'bool'},
                                                           'index': {'doc': 'Index of the key for which the tangent type is to be set ',
                                                                     'type': 'uint'},
                                                           'weight': {'doc': 'The weight to set the tangent ',
                                                                      'type': 'double'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in'),
                                                        ('angle',
                                                         'MAngle',
                                                         'in'),
                                                        ('weight',
                                                         'double',
                                                         'in'),
                                                        ('inTangent',
                                                         'bool',
                                                         'in'),
                                                        ('change',
                                                         'MAnimCurveChange',
                                                         'in'),
                                                        ('convertUnits',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'change': None,
                                                            'convertUnits': True},
                                               'deprecated': False,
                                               'doc': '\r\nSets the tangent for the key at the specified index. If convertUnits is true (the default) the x value will be scaled by the current UI time units and the y value will be scaled by the relevant UI units for the output type of the animation curve (i.e. linear units for a curve that outputs linear data, and so on).',
                                               'inArgs': ['index',
                                                          'angle',
                                                          'weight',
                                                          'inTangent',
                                                          'change',
                                                          'convertUnits'],
                                               'inverse': ('getTangent',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'angle': ['const',
                                                                            '&'],
                                                                  'change': ['*'],
                                                                  'convertUnits': [],
                                                                  'inTangent': [],
                                                                  'index': ['unsigned'],
                                                                  'weight': []},
                                               'types': {'angle': 'MAngle',
                                                         'change': 'MAnimCurveChange',
                                                         'convertUnits': 'bool',
                                                         'inTangent': 'bool',
                                                         'index': 'uint',
                                                         'weight': 'double'}}],
                               'setTangentTypes': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                           'type': 'MAnimCurveChange'},
                                                                'inTangentType': {'doc': 'Type to which the in tangent is to be set ',
                                                                                  'type': ('MFnAnimCurve',
                                                                                           'TangentType')},
                                                                'indexArray': {'doc': 'Indices of the key for which the tangent type is to be set ',
                                                                               'type': 'MIntArray'},
                                                                'outTangentType': {'doc': 'Type to which the out tangent is to be set ',
                                                                                   'type': ('MFnAnimCurve',
                                                                                            'TangentType')}},
                                                    'args': [('indexArray',
                                                              'MIntArray',
                                                              'in'),
                                                             ('inTangentType',
                                                              ('MFnAnimCurve',
                                                               'TangentType'),
                                                              'in'),
                                                             ('outTangentType',
                                                              ('MFnAnimCurve',
                                                               'TangentType'),
                                                              'in'),
                                                             ('change',
                                                              'MAnimCurveChange',
                                                              'in')],
                                                    'defaults': {'change': None,
                                                                 'inTangentType': ('MFnAnimCurve',
                                                                                   'TangentType',
                                                                                   'kTangentGlobal'),
                                                                 'outTangentType': ('MFnAnimCurve',
                                                                                    'TangentType',
                                                                                    'kTangentGlobal')},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the tangent types for multiple keys.',
                                                    'inArgs': ['indexArray',
                                                               'inTangentType',
                                                               'outTangentType',
                                                               'change'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'change': ['*'],
                                                                       'inTangentType': [],
                                                                       'indexArray': [],
                                                                       'outTangentType': []},
                                                    'types': {'change': 'MAnimCurveChange',
                                                              'inTangentType': ('MFnAnimCurve',
                                                                                'TangentType'),
                                                              'indexArray': 'MIntArray',
                                                              'outTangentType': ('MFnAnimCurve',
                                                                                 'TangentType')}}],
                               'setTangentsLocked': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                             'type': 'MAnimCurveChange'},
                                                                  'index': {'doc': 'Index of the key at which to set/unset the locks ',
                                                                            'type': 'uint'},
                                                                  'locked': {'doc': 'true if the tangents are to be locked, false otherwise ',
                                                                             'type': 'bool'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in'),
                                                               ('locked',
                                                                'bool',
                                                                'in'),
                                                               ('change',
                                                                'MAnimCurveChange',
                                                                'in')],
                                                      'defaults': {'change': None},
                                                      'deprecated': False,
                                                      'doc': '\r\nLock or unlock the tangents at the given key.',
                                                      'inArgs': ['index',
                                                                 'locked',
                                                                 'change'],
                                                      'inverse': ('tangentsLocked',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'change': ['*'],
                                                                         'index': ['unsigned'],
                                                                         'locked': []},
                                                      'types': {'change': 'MAnimCurveChange',
                                                                'index': 'uint',
                                                                'locked': 'bool'}}],
                               'setTime': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                   'type': 'MAnimCurveChange'},
                                                        'index': {'doc': 'Index of the key for which the time is to be set ',
                                                                  'type': 'uint'},
                                                        'time': {'doc': 'Time to which the indexed key time is to be set ',
                                                                 'type': 'MTime'}},
                                            'args': [('index',
                                                      'uint',
                                                      'in'),
                                                     ('time',
                                                      'MTime',
                                                      'in'),
                                                     ('change',
                                                      'MAnimCurveChange',
                                                      'in')],
                                            'defaults': {'change': None},
                                            'deprecated': False,
                                            'doc': '\r\nSets the time of the key at the specified index. This will fail if setting the time would require re-ordering of the keys. This method should only be used on Anim Curves of type kAnimCurveT*.',
                                            'inArgs': ['index',
                                                       'time',
                                                       'change'],
                                            'inverse': ('time', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'change': ['*'],
                                                               'index': ['unsigned'],
                                                               'time': ['const',
                                                                        '&']},
                                            'types': {'change': 'MAnimCurveChange',
                                                      'index': 'uint',
                                                      'time': 'MTime'}}],
                               'setUnitlessInput': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                            'type': 'MAnimCurveChange'},
                                                                 'index': {'doc': 'Index of the key for which the unitless input value is to be set ',
                                                                           'type': 'uint'},
                                                                 'unitlessInput': {'doc': 'Value to which the indexed key unitless input value is to be set ',
                                                                                   'type': 'double'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('unitlessInput',
                                                               'double',
                                                               'in'),
                                                              ('change',
                                                               'MAnimCurveChange',
                                                               'in')],
                                                     'defaults': {'change': None},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the value of the unitless input of the key at the specified index. This will fail if setting the value would require re-ordering of the keys. This method should only be used on Anim Curves of type kAnimCurveU*.',
                                                     'inArgs': ['index',
                                                                'unitlessInput',
                                                                'change'],
                                                     'inverse': ('unitlessInput',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'change': ['*'],
                                                                        'index': ['unsigned'],
                                                                        'unitlessInput': []},
                                                     'types': {'change': 'MAnimCurveChange',
                                                               'index': 'uint',
                                                               'unitlessInput': 'double'}}],
                               'setValue': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                    'type': 'MAnimCurveChange'},
                                                         'index': {'doc': 'Index of the key for which the value is to be set ',
                                                                   'type': 'uint'},
                                                         'value': {'doc': 'Value to which the key is to be set ',
                                                                   'type': 'double'}},
                                             'args': [('index',
                                                       'uint',
                                                       'in'),
                                                      ('value',
                                                       'double',
                                                       'in'),
                                                      ('change',
                                                       'MAnimCurveChange',
                                                       'in')],
                                             'defaults': {'change': None},
                                             'deprecated': False,
                                             'doc': '\r\nSets the value of the key at the specified index. This method should only be used on Anim Curves of type kAnimCurve*A, kAnimCurve*L or kAnimCurve*U.',
                                             'inArgs': ['index',
                                                        'value',
                                                        'change'],
                                             'inverse': ('value', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'change': ['*'],
                                                                'index': ['unsigned'],
                                                                'value': []},
                                             'types': {'change': 'MAnimCurveChange',
                                                       'index': 'uint',
                                                       'value': 'double'}}],
                               'setWeight': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                     'type': 'MAnimCurveChange'},
                                                          'inTangent': {'doc': 'If true, set the in-tangent, else set out-tangent ',
                                                                        'type': 'bool'},
                                                          'index': {'doc': 'Index of the key ',
                                                                    'type': 'uint'},
                                                          'weight': {'doc': "The new in- or out-weight for the key's tangent ",
                                                                     'type': 'double'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in'),
                                                       ('weight',
                                                        'double',
                                                        'in'),
                                                       ('inTangent',
                                                        'bool',
                                                        'in'),
                                                       ('change',
                                                        'MAnimCurveChange',
                                                        'in')],
                                              'defaults': {'change': None},
                                              'deprecated': False,
                                              'doc': '\r\nSet the in- or out-weight of the tangent for the key at the given index',
                                              'inArgs': ['index',
                                                         'weight',
                                                         'inTangent',
                                                         'change'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'change': ['*'],
                                                                 'inTangent': [],
                                                                 'index': ['unsigned'],
                                                                 'weight': []},
                                              'types': {'change': 'MAnimCurveChange',
                                                        'inTangent': 'bool',
                                                        'index': 'uint',
                                                        'weight': 'double'}}],
                               'setWeightsLocked': [{'argInfo': {'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                            'type': 'MAnimCurveChange'},
                                                                 'index': {'doc': 'Index of the key at which to set/unset the locks ',
                                                                           'type': 'uint'},
                                                                 'locked': {'doc': 'true if the weights are to be locked, false otherwise ',
                                                                            'type': 'bool'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in'),
                                                              ('locked',
                                                               'bool',
                                                               'in'),
                                                              ('change',
                                                               'MAnimCurveChange',
                                                               'in')],
                                                     'defaults': {'change': None},
                                                     'deprecated': False,
                                                     'doc': '\r\nLock or unlock the weights at the given key.',
                                                     'inArgs': ['index',
                                                                'locked',
                                                                'change'],
                                                     'inverse': ('weightsLocked',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'change': ['*'],
                                                                        'index': ['unsigned'],
                                                                        'locked': []},
                                                     'types': {'change': 'MAnimCurveChange',
                                                               'index': 'uint',
                                                               'locked': 'bool'}}],
                               'tangentsLocked': [{'argInfo': {'index': {'doc': 'Index of the key to check for locked tangents ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines whether the tangents are locked at the given key.',
                                                   'inArgs': ['index'],
                                                   'inverse': ('setTangentsLocked',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Boolean value: true if the tangents are locked, false otherwise.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                               'time': [{'argInfo': {'index': {'doc': 'Index of the key for which the time is required ',
                                                               'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nDetermines the time of the key at the specified index.',
                                         'inArgs': ['index'],
                                         'inverse': ('setTime', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Time of the key at the given index. The unit defaults to MTime::kFilm (i.e., 24 frames/second)',
                                                        'qualifiers': [],
                                                        'type': 'MTime'},
                                         'returnType': 'MTime',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': ['unsigned']},
                                         'types': {'index': 'uint'}}],
                               'timedAnimCurveTypeForPlug': [{'argInfo': {'plug': {'doc': 'plug ',
                                                                                   'type': 'MPlug'}},
                                                              'args': [('plug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns the timed animCurve type appropriate for the specified plug.',
                                                              'inArgs': ['plug'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The animCurve type.',
                                                                             'qualifiers': [],
                                                                             'type': ('MFnAnimCurve',
                                                                                      'AnimCurveType')},
                                                              'returnType': ('MFnAnimCurve',
                                                                             'AnimCurveType'),
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'plug': ['&']},
                                                              'types': {'plug': 'MPlug'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'unitlessAnimCurveTypeForPlug': [{'argInfo': {'plug': {'doc': 'plug ',
                                                                                      'type': 'MPlug'}},
                                                                 'args': [('plug',
                                                                           'MPlug',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nReturns the unitless animCurve type appropriate for the specified plug.',
                                                                 'inArgs': ['plug'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'The animCurve type.',
                                                                                'qualifiers': [],
                                                                                'type': ('MFnAnimCurve',
                                                                                         'AnimCurveType')},
                                                                 'returnType': ('MFnAnimCurve',
                                                                                'AnimCurveType'),
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'plug': ['&']},
                                                                 'types': {'plug': 'MPlug'}}],
                               'unitlessInput': [{'argInfo': {'index': {'doc': 'Index of the key for which the input value is required ',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermines the unitless input value of the key at the specified index. This method should only be used on Anim Curves of type kAnimCurveU*.',
                                                  'inArgs': ['index'],
                                                  'inverse': ('setUnitlessInput',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Input value at which the key is set',
                                                                 'qualifiers': [],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}],
                               'value': [{'argInfo': {'index': {'doc': 'Index of the key for which the value is required ',
                                                                'type': 'uint'}},
                                          'args': [('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermines the value of the key at the specified index. This method should only be used on Anim Curves of type kAnimCurve*A, kAnimCurve*L or kAnimCurve*U.',
                                          'inArgs': ['index'],
                                          'inverse': ('setValue', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Value of the key',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'index': ['unsigned']},
                                          'types': {'index': 'uint'}}],
                               'weightsLocked': [{'argInfo': {'index': {'doc': 'Index of the key to check for locked weights ',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermines whether the weights are locked at the given key.',
                                                  'inArgs': ['index'],
                                                  'inverse': ('setWeightsLocked',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Boolean value: true if the weights are locked, false otherwise.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}]},
                   'pymelEnums': {'AnimCurveType': "Enum('AnimCurveType', [('TA', 0), ('kAnimCurveTA', 0), ('TL', 1), ('kAnimCurveTL', 1), ('TT', 2), ('kAnimCurveTT', 2), ('TU', 3), ('kAnimCurveTU', 3), ('UA', 4), ('kAnimCurveUA', 4), ('UL', 5), ('kAnimCurveUL', 5), ('UT', 6), ('kAnimCurveUT', 6), ('UU', 7), ('kAnimCurveUU', 7), ('unknown', 8), ('kAnimCurveUnknown', 8)], multiKeys=True)",
                                  'InfinityType': "Enum('InfinityType', [('constant', 0), ('kConstant', 0), ('linear', 1), ('kLinear', 1), ('cycle', 3), ('kCycle', 3), ('cycleRelative', 4), ('kCycleRelative', 4), ('oscillate', 5), ('kOscillate', 5)], multiKeys=True)",
                                  'TangentType': "Enum('TangentType', [('global_', 0), ('kTangentGlobal', 0), ('fixed', 1), ('kTangentFixed', 1), ('linear', 2), ('kTangentLinear', 2), ('flat', 3), ('kTangentFlat', 3), ('smooth', 4), ('kTangentSmooth', 4), ('step', 5), ('kTangentStep', 5), ('slow', 6), ('kTangentSlow', 6), ('fast', 7), ('kTangentFast', 7), ('clamped', 8), ('kTangentClamped', 8), ('plateau', 9), ('kTangentPlateau', 9), ('stepNext', 10), ('kTangentStepNext', 10), ('auto', 11), ('kTangentAuto', 11)], multiKeys=True)"},
                   'pymelMethods': {'inTangentType': 'getInTangentType',
                                    'outTangentType': 'getOutTangentType',
                                    'postInfinityType': 'getPostInfinityType',
                                    'preInfinityType': 'getPreInfinityType',
                                    'setIsBreakdown': 'setBreakdown',
                                    'setIsWeighted': 'setWeighted',
                                    'tangentsLocked': 'getTangentsLocked',
                                    'time': 'getTime',
                                    'unitlessInput': 'getUnitlessInput',
                                    'value': 'getValue',
                                    'weightsLocked': 'getWeightsLocked'}},
  'MFnAnisotropyShader': {'enums': {},
                          'invertibles': [('setTangentUCamera',
                                           'tangentUCamera'),
                                          ('setCorrelationY',
                                           'correlationY'),
                                          ('setTangentVCamera',
                                           'tangentVCamera'),
                                          ('setRotateAngle', 'rotateAngle'),
                                          ('setRefractiveIndex',
                                           'refractiveIndex'),
                                          ('setCorrelationX',
                                           'correlationX'),
                                          ('setAnisotropicReflectivity',
                                           'anisotropicReflectivity'),
                                          ('setRoughness', 'roughness')],
                          'methods': {'anisotropicReflectivity': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nRetrieves the value of the "anisotropicReflectivity" attribute of a layered shader node.',
                                                                   'inArgs': [],
                                                                   'inverse': ('setAnisotropicReflectivity',
                                                                               False),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'The value of the "anisotropicReflectivity" attribute of the shader node.',
                                                                                  'qualifiers': [],
                                                                                  'type': 'bool'},
                                                                   'returnType': 'bool',
                                                                   'static': False,
                                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                                   'types': {}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nClass name. \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'correlationX': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieves the value of the "spreadX" attribute of a shader node.',
                                                        'inArgs': [],
                                                        'inverse': ('setCorrelationX',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "spreadX" attribute of the shader node.',
                                                                       'qualifiers': [],
                                                                       'type': 'float'},
                                                        'returnType': 'float',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                      'correlationY': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieves the value of the "spreadY" attribute of a shader node.',
                                                        'inArgs': [],
                                                        'inverse': ('setCorrelationY',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "spreadY" attribute of the shader node.',
                                                                       'qualifiers': [],
                                                                       'type': 'float'},
                                                        'returnType': 'float',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                      'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not the new node will be connected to the shader classification node. ',
                                                                            'type': 'bool'}},
                                                  'args': [('UIvisible',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'UIvisible': True},
                                                  'deprecated': False,
                                                  'doc': '\nCreates a new layered shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.',
                                                  'inArgs': ['UIvisible'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'UIvisible': []},
                                                  'types': {'UIvisible': 'bool'}}],
                                      'refractiveIndex': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nRetrieves the value of the "fresnelRefractiveIndex" attribute of a layered shader node.',
                                                           'inArgs': [],
                                                           'inverse': ('setRefractiveIndex',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The value of the "fresnelRefractiveIndex" attribute of the shader node.',
                                                                          'qualifiers': [],
                                                                          'type': 'float'},
                                                           'returnType': 'float',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                      'rotateAngle': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nRetrieves the value of the "angle" attribute of a layered shader node.',
                                                       'inArgs': [],
                                                       'inverse': ('setRotateAngle',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The value of the "angle" attribute of the shader node.',
                                                                      'qualifiers': [],
                                                                      'type': 'float'},
                                                       'returnType': 'float',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                      'roughness': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the value of the "roughness" attribute of a shader node.',
                                                     'inArgs': [],
                                                     'inverse': ('setRoughness',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "roughness" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                      'setAnisotropicReflectivity': [{'argInfo': {'anisotropic_reflectivity': {'doc': 'value to which the attribute will be set.',
                                                                                                               'type': 'bool'}},
                                                                      'args': [('anisotropic_reflectivity',
                                                                                'bool',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\nSets the value of the "anisotropicReflectivity" attribute of a shader node.',
                                                                      'inArgs': ['anisotropic_reflectivity'],
                                                                      'inverse': ('anisotropicReflectivity',
                                                                                  True),
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': None},
                                                                      'returnType': None,
                                                                      'static': False,
                                                                      'typeQualifiers': {'anisotropic_reflectivity': ['const',
                                                                                                                      '&']},
                                                                      'types': {'anisotropic_reflectivity': 'bool'}}],
                                      'setCorrelationX': [{'argInfo': {'correl_x': {'doc': 'value to which the attribute will be set.',
                                                                                    'type': 'float'}},
                                                           'args': [('correl_x',
                                                                     'float',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the value of the "spreadX" attribute of a shader node.',
                                                           'inArgs': ['correl_x'],
                                                           'inverse': ('correlationX',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'correl_x': ['const',
                                                                                           '&']},
                                                           'types': {'correl_x': 'float'}}],
                                      'setCorrelationY': [{'argInfo': {'correl_y': {'doc': 'value to which the attribute will be set.',
                                                                                    'type': 'float'}},
                                                           'args': [('correl_y',
                                                                     'float',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the value of the "spreadY" attribute of a shader node.',
                                                           'inArgs': ['correl_y'],
                                                           'inverse': ('correlationY',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'correl_y': ['const',
                                                                                           '&']},
                                                           'types': {'correl_y': 'float'}}],
                                      'setRefractiveIndex': [{'argInfo': {'refractive_index': {'doc': 'value to which the attribute will be set.',
                                                                                               'type': 'float'}},
                                                              'args': [('refractive_index',
                                                                        'float',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the value of the "fresnelRefractiveIndex" attribute of a shader node.',
                                                              'inArgs': ['refractive_index'],
                                                              'inverse': ('refractiveIndex',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'refractive_index': ['const',
                                                                                                      '&']},
                                                              'types': {'refractive_index': 'float'}}],
                                      'setRotateAngle': [{'argInfo': {'rotate_angle': {'doc': 'value to which the attribute will be set.',
                                                                                       'type': 'float'}},
                                                          'args': [('rotate_angle',
                                                                    'float',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the value of the "angle" attribute of a shader node.',
                                                          'inArgs': ['rotate_angle'],
                                                          'inverse': ('rotateAngle',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'rotate_angle': ['const',
                                                                                              '&']},
                                                          'types': {'rotate_angle': 'float'}}],
                                      'setRoughness': [{'argInfo': {'roughness': {'doc': 'value to which the attribute will be set.',
                                                                                  'type': 'float'}},
                                                        'args': [('roughness',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the value of the "roughness" attribute of a shader node.',
                                                        'inArgs': ['roughness'],
                                                        'inverse': ('roughness',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'roughness': ['const',
                                                                                         '&']},
                                                        'types': {'roughness': 'float'}}],
                                      'setTangentUCamera': [{'argInfo': {'tangu_camera': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'MColor'}},
                                                             'args': [('tangu_camera',
                                                                       'MColor',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nSets the value of the "color" attribute of a shader node.',
                                                             'inArgs': ['tangu_camera'],
                                                             'inverse': ('tangentUCamera',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'tangu_camera': ['const',
                                                                                                 '&']},
                                                             'types': {'tangu_camera': 'MColor'}}],
                                      'setTangentVCamera': [{'argInfo': {'tangv_camera': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'MColor'}},
                                                             'args': [('tangv_camera',
                                                                       'MColor',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nSets the value of the "transparency" attribute of a shader node.',
                                                             'inArgs': ['tangv_camera'],
                                                             'inverse': ('tangentVCamera',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'tangv_camera': ['const',
                                                                                                 '&']},
                                                             'types': {'tangv_camera': 'MColor'}}],
                                      'tangentUCamera': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nRetrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.',
                                                          'inArgs': [],
                                                          'inverse': ('setTangentUCamera',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The value of the "color" attribute of the shader node.',
                                                                         'qualifiers': [],
                                                                         'type': 'MColor'},
                                                          'returnType': 'MColor',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                      'tangentVCamera': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nRetrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.',
                                                          'inArgs': [],
                                                          'inverse': ('setTangentVCamera',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The value of the "transparency" attribute of the shader node.',
                                                                         'qualifiers': [],
                                                                         'type': 'MColor'},
                                                          'returnType': 'MColor',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nFunction set type. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'anisotropicReflectivity': 'getAnisotropicReflectivity',
                                           'correlationX': 'getCorrelationX',
                                           'correlationY': 'getCorrelationY',
                                           'refractiveIndex': 'getRefractiveIndex',
                                           'rotateAngle': 'getRotateAngle',
                                           'roughness': 'getRoughness',
                                           'tangentUCamera': 'getTangentUCamera',
                                           'tangentVCamera': 'getTangentVCamera'}},
  'MFnAreaLight': {'enums': {},
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nClass name. \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                     'type': 'bool'}},
                                           'args': [('UIvisible',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'UIvisible': True},
                                           'deprecated': False,
                                           'doc': '\nCreates a new area light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                           'inArgs': ['UIvisible'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'UIvisible': []},
                                           'types': {'UIvisible': 'bool'}},
                                          {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                     'type': 'bool'},
                                                       'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                  'type': 'MObject'},
                                                       'wantTransform': {'doc': "Boolean to indicate whether the transform node is needed or not, which is 'false' by default. ",
                                                                         'type': 'bool'}},
                                           'args': [('parent',
                                                     'MObject',
                                                     'in'),
                                                    ('UIvisible',
                                                     'bool',
                                                     'in'),
                                                    ('wantTransform',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'UIvisible': True,
                                                        'wantTransform': False},
                                           'deprecated': False,
                                           'doc': '\nCreates a new area light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                           'inArgs': ['parent',
                                                      'UIvisible',
                                                      'wantTransform'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'UIvisible': [],
                                                              'parent': ['const',
                                                                         '&'],
                                                              'wantTransform': []},
                                           'types': {'UIvisible': 'bool',
                                                     'parent': 'MObject',
                                                     'wantTransform': 'bool'}},
                                          {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                     'type': 'bool'},
                                                       'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                  'type': 'MObject'}},
                                           'args': [('parent',
                                                     'MObject',
                                                     'in'),
                                                    ('UIvisible',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'UIvisible': True},
                                           'deprecated': False,
                                           'doc': '\nNO SCRIPT SUPPORT. \n',
                                           'inArgs': ['parent',
                                                      'UIvisible'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'UIvisible': [],
                                                              'parent': ['const',
                                                                         '&']},
                                           'types': {'UIvisible': 'bool',
                                                     'parent': 'MObject'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nFunction set type. \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {}},
  'MFnArrayAttrsData': {'enums': {'Type': {'valueDocs': {'doubleArray': 'use',
                                                         'intArray': 'use',
                                                         'invalid': 'Invalid value.',
                                                         'kDoubleArray': 'use',
                                                         'kIntArray': 'use',
                                                         'kInvalid': 'Invalid value.',
                                                         'kLast': 'Last value. It does not represent real data, but can be used to loop on all possible types',
                                                         'kStringArray': 'use',
                                                         'kVectorArray': 'use',
                                                         'last': 'Last value. It does not represent real data, but can be used to loop on all possible types',
                                                         'stringArray': 'use',
                                                         'vectorArray': 'use'},
                                           'values': "Enum('Type', {'kInvalid': 0, 'kVectorArray': 1, 'kDoubleArray': 2, 'kIntArray': 3, 'kStringArray': 4, 'kLast': 5})"}},
                        'methods': {'checkArrayExist': [{'argInfo': {'arrayType': {'doc': 'the type of the array ',
                                                                                   'type': ('MFnArrayAttrsData',
                                                                                            'Type')},
                                                                     'name': {'doc': 'the name of the array to check ',
                                                                              'type': 'MString'}},
                                                         'args': [('name',
                                                                   'MString',
                                                                   'in'),
                                                                  ('arrayType',
                                                                   ('MFnArrayAttrsData',
                                                                    'Type'),
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nCheck if the attribute array related to the given name has been created. If the named array exists return true and the array data type.',
                                                         'inArgs': ['name'],
                                                         'outArgs': ['arrayType'],
                                                         'returnInfo': {'doc': 'True if the array exists and false otherwise. ',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'arrayType': ['&'],
                                                                            'name': ['const']},
                                                         'types': {'arrayType': ('MFnArrayAttrsData',
                                                                                 'Type'),
                                                                   'name': 'MString'}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nClass name. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'clear': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClear the contents of all of the arrays.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'count': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the number of attribute arrays.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to be empty.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The newly created MObject ',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                    'doubleArray': [{'argInfo': {'name': {'doc': 'the name of the array to edit or create. ',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn an  MDoubleArray  containing the double array currently operated upon by the function set. The  MDoubleArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.',
                                                     'inArgs': ['name'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A copy of the MDoubleArray held in this instance ',
                                                                    'qualifiers': [],
                                                                    'type': 'MDoubleArray'},
                                                     'returnType': 'MDoubleArray',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'name': ['const']},
                                                     'types': {'name': 'MString'}}],
                                    'getDoubleData': [{'argInfo': {'attrName': {'doc': 'the name of the array to edit or create. ',
                                                                                'type': 'MString'}},
                                                       'args': [('attrName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn an  MDoubleArray  containing the double array currently operated upon by the function set. The  MDoubleArray  returned by this method is read only. If the array did not exist it will be created.',
                                                       'inArgs': ['attrName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A copy of the MDoubleArray held in this instance ',
                                                                      'qualifiers': [],
                                                                      'type': 'MDoubleArray'},
                                                       'returnType': 'MDoubleArray',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'attrName': ['const']},
                                                       'types': {'attrName': 'MString'}}],
                                    'getIntData': [{'argInfo': {'attrName': {'doc': 'the name of the array to edit or create. ',
                                                                             'type': 'MString'}},
                                                    'args': [('attrName',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn an  MIntArray  containing the int array currently operated upon by the function set. The  MIntArray  returned by this method is read only. If the array did not exist it will be created.',
                                                    'inArgs': ['attrName'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A copy of the MIntArray held in this instance ',
                                                                   'qualifiers': [],
                                                                   'type': 'MIntArray'},
                                                    'returnType': 'MIntArray',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'attrName': ['const']},
                                                    'types': {'attrName': 'MString'}}],
                                    'getStringData': [{'argInfo': {'attrName': {'doc': 'the name of the array to edit or create. ',
                                                                                'type': 'MString'}},
                                                       'args': [('attrName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn an  MStringArray  containing the string array currently operated upon by the function set. The  MStringArray  returned by this method is read only. If the array did not exist it will be created.',
                                                       'inArgs': ['attrName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A copy of the MStringArray held in this instance ',
                                                                      'qualifiers': [],
                                                                      'type': 'MStringArray'},
                                                       'returnType': 'MStringArray',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'attrName': ['const']},
                                                       'types': {'attrName': 'MString'}}],
                                    'getVectorData': [{'argInfo': {'attrName': {'doc': 'the name of the array to read ',
                                                                                'type': 'MString'}},
                                                       'args': [('attrName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn an  MVectorArray  containing the vector array currently operated upon by the function set. The  MVectorArray  returned by this method is read only. If the array did not exist it will be created.',
                                                       'inArgs': ['attrName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A copy of the MVectorArray held in this instance ',
                                                                      'qualifiers': [],
                                                                      'type': 'MVectorArray'},
                                                       'returnType': 'MVectorArray',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'attrName': ['const']},
                                                       'types': {'attrName': 'MString'}}],
                                    'intArray': [{'argInfo': {'name': {'doc': 'the name of the array to edit or create. ',
                                                                       'type': 'MString'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn an  MIntArray  containing the int array currently operated upon by the function set. The  MIntArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.',
                                                  'inArgs': ['name'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'A copy of the MIntArray held in this instance ',
                                                                 'qualifiers': [],
                                                                 'type': 'MIntArray'},
                                                  'returnType': 'MIntArray',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'name': ['const']},
                                                  'types': {'name': 'MString'}}],
                                    'list': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns a list of names for the attribute arrays.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A list of all the names of all the arrays stored in the data. ',
                                                             'qualifiers': [],
                                                             'type': 'MStringArray'},
                                              'returnType': 'MStringArray',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                    'stringArray': [{'argInfo': {'name': {'doc': 'the name of the array to edit or create. ',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn an  MStringArray  containing the string array currently operated upon by the function set. The  MStringArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.',
                                                     'inArgs': ['name'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A copy of the MStringArray held in this instance ',
                                                                    'qualifiers': [],
                                                                    'type': 'MStringArray'},
                                                     'returnType': 'MStringArray',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'name': ['const']},
                                                     'types': {'name': 'MString'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFunction set type. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'vectorArray': [{'argInfo': {'name': {'doc': 'the name of the array to edit or create. ',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn an  MVectorArray  containing the vector array currently operated upon by the function set. The  MVectorArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.',
                                                     'inArgs': ['name'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A copy of the MVectorArray held in this instance ',
                                                                    'qualifiers': [],
                                                                    'type': 'MVectorArray'},
                                                     'returnType': 'MVectorArray',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'name': ['const']},
                                                     'types': {'name': 'MString'}}]},
                        'pymelEnums': {'Type': "Enum('Type', [('invalid', 0), ('kInvalid', 0), ('vectorArray', 1), ('kVectorArray', 1), ('doubleArray', 2), ('kDoubleArray', 2), ('intArray', 3), ('kIntArray', 3), ('stringArray', 4), ('kStringArray', 4), ('last', 5), ('kLast', 5)], multiKeys=True)"}},
  'MFnAssembly': {'enums': {},
                  'invertibles': [('setRepLabel', 'getRepLabel')],
                  'methods': {'activate': [{'argInfo': {'representation': {'doc': 'Representation to activate. ',
                                                                           'type': 'MString'}},
                                            'args': [('representation',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nActivate a representation. The representation to activate is specified as a string name. Passing in an empty string argument means inactivate the previously-active representation (if any), and activate no representation.',
                                            'inArgs': ['representation'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'representation': ['const',
                                                                                  '&']},
                                            'types': {'representation': 'MString'}}],
                              'activateNonRecursive': [{'argInfo': {'representation': {'doc': 'Representation to activate. ',
                                                                                       'type': 'MString'}},
                                                        'args': [('representation',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nActivate a representation, but prevent any nested assemblies created and initialized during this activation from activating any of their representations.',
                                                        'inArgs': ['representation'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'representation': ['const',
                                                                                              '&']},
                                                        'types': {'representation': 'MString'}}],
                              'canActivate': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nDetermines whether this assembly can activate a representation, for the node attached to this function set.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if activation is allowed, false otherwise. ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'status': ['*']},
                                               'types': {}}],
                              'canRepApplyEdits': [{'argInfo': {'representation': {'doc': 'Representation to query. ',
                                                                                   'type': 'MString'}},
                                                    'args': [('representation',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nDetermines whether the given representation can apply edits to its data, for the node attached to this function set.',
                                                    'inArgs': ['representation'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'true if the representation can apply edits, false otherwise. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'representation': ['const',
                                                                                          '&'],
                                                                       'status': ['*']},
                                                    'types': {'representation': 'MString'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nClass name. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'createRepresentation': [{'argInfo': {'input': {'doc': 'Input data for representation creation. ',
                                                                              'type': 'MString'},
                                                                    'type': {'doc': 'Type of representation to create. ',
                                                                             'type': 'MString'},
                                                                    'undoRedo': {'doc': 'Pointer to MDagModifier object, for undo / redo purposes. ',
                                                                                 'type': 'MDagModifier'}},
                                                        'args': [('input',
                                                                  'MString',
                                                                  'in'),
                                                                 ('type',
                                                                  'MString',
                                                                  'in'),
                                                                 ('undoRedo',
                                                                  'MDagModifier',
                                                                  'out')],
                                                        'defaults': {'undoRedo': None},
                                                        'deprecated': False,
                                                        'doc': '\nCreate a representation and add it to the list of those managed by this node.',
                                                        'inArgs': ['input',
                                                                   'type'],
                                                        'outArgs': ['undoRedo'],
                                                        'returnInfo': {'doc': 'Added representation name. ',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {'input': ['const',
                                                                                     '&'],
                                                                           'status': ['*'],
                                                                           'type': ['const',
                                                                                    '&'],
                                                                           'undoRedo': ['*']},
                                                        'types': {'input': 'MString',
                                                                  'type': 'MString',
                                                                  'undoRedo': 'MDagModifier'}},
                                                       {'argInfo': {'input': {'doc': 'Input data for representation creation. ',
                                                                              'type': 'MString'},
                                                                    'representation': {'doc': 'Representation name starting point. ',
                                                                                       'type': 'MString'},
                                                                    'type': {'doc': 'Type of representation to create. ',
                                                                             'type': 'MString'},
                                                                    'undoRedo': {'doc': 'Pointer to MDagModifier object, for undo / redo purposes. ',
                                                                                 'type': 'MDagModifier'}},
                                                        'args': [('input',
                                                                  'MString',
                                                                  'in'),
                                                                 ('type',
                                                                  'MString',
                                                                  'in'),
                                                                 ('representation',
                                                                  'MString',
                                                                  'in'),
                                                                 ('undoRedo',
                                                                  'MDagModifier',
                                                                  'out')],
                                                        'defaults': {'undoRedo': None},
                                                        'deprecated': False,
                                                        'doc': '\nCreate a representation and add it to the list of those managed by this node.',
                                                        'inArgs': ['input',
                                                                   'type',
                                                                   'representation'],
                                                        'outArgs': ['undoRedo'],
                                                        'returnInfo': {'doc': 'Added representation name. ',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {'input': ['const',
                                                                                     '&'],
                                                                           'representation': ['const',
                                                                                              '&'],
                                                                           'status': ['*'],
                                                                           'type': ['const',
                                                                                    '&'],
                                                                           'undoRedo': ['*']},
                                                        'types': {'input': 'MString',
                                                                  'representation': 'MString',
                                                                  'type': 'MString',
                                                                  'undoRedo': 'MDagModifier'}}],
                              'deleteAllRepresentations': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nDelete all representations managed by the node attached to this function set.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                              'deleteRepresentation': [{'argInfo': {'representation': {'doc': 'Representation to delete.',
                                                                                       'type': 'MString'}},
                                                        'args': [('representation',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nDelete a representation managed by the node attached to this function set.',
                                                        'inArgs': ['representation'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'representation': ['const',
                                                                                              '&']},
                                                        'types': {'representation': 'MString'}}],
                              'getAbsoluteRepNamespace': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nGet the fully-qualified (absolute) namespace for representations of this assembly node. This is the namespace where nodes created by the activation of a representation will be added. This namespace is shared by all representations.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The fully-qualified (absolute) namespace for representations of this assembly node. The name can be empty if the namespace has not been created yet. ',
                                                                          'qualifiers': [],
                                                                          'type': 'MString'},
                                                           'returnType': 'MString',
                                                           'static': False,
                                                           'typeQualifiers': {'status': ['*']},
                                                           'types': {}}],
                              'getActive': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nGet the active representation in the list of representations. If the list of representations is empty, the status code will be kSuccess, and the return string will be empty.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The active representation. ',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': False,
                                             'typeQualifiers': {'status': ['*']},
                                             'types': {}}],
                              'getInitialRep': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': True,
                                                 'doc': '\n Deprecated: Use the method MFnAssembly::getInitialRep(bool&, MStatus*) instead \nGet the initial representation to use when the assembly is first loaded.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The initial representation to use, if any, else an empty string.',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': False,
                                                 'typeQualifiers': {'status': ['*']},
                                                 'types': {}},
                                                {'argInfo': {'hasInitialRep': {'doc': 'Return whether or not we have an initial representation ',
                                                                               'type': 'bool'}},
                                                 'args': [('hasInitialRep',
                                                           'bool',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nGet the initial representation to use when the assembly is first loaded.',
                                                 'inArgs': [],
                                                 'outArgs': ['hasInitialRep'],
                                                 'returnInfo': {'doc': 'The initial representation to use, if any, else an empty string.',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': False,
                                                 'typeQualifiers': {'hasInitialRep': ['&'],
                                                                    'status': ['*']},
                                                 'types': {'hasInitialRep': 'bool'}}],
                              'getParentAssembly': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturn the immediate parent assembly of this assembly if there is one, otherwise return a null object. An assembly with no parent is a top level assembly.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Parent assembly, or a null object if this assembly has no parent assembly ',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'status': ['*']},
                                                     'types': {}}],
                              'getRepLabel': [{'argInfo': {'representation': {'doc': 'Representation whose label must be returned. ',
                                                                              'type': 'MString'}},
                                               'args': [('representation',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nGet the label of the specified representation. The label of a representation is a string that is meant to be shown in the UI and identify the representation meaningfully to a user. The representation label should support localization requirements. If the specified representation is not found in this assembly, an empty string is returned.',
                                               'inArgs': ['representation'],
                                               'inverse': ('setRepLabel',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The representation label. ',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {'representation': ['const',
                                                                                     '&'],
                                                                  'status': ['*']},
                                               'types': {'representation': 'MString'}}],
                              'getRepNamespace': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nGet the representations namespace of this assembly node. This is the namespace where nodes created by the activation of a representation will be added. This namespace is shared by all representations. The name can be updated by Maya if a name clash occurs when the namespace is added to its parent namespace (see  MPxAssembly::updateRepNamespace()  for details).',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Namespace for representations. ',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': False,
                                                   'typeQualifiers': {'status': ['*']},
                                                   'types': {}}],
                              'getRepType': [{'argInfo': {'representation': {'doc': 'Representation whose type must be returned. ',
                                                                             'type': 'MString'}},
                                              'args': [('representation',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nGet the type of the specified representation. The type string does not have to be user-readable, and does not have to be localized; the type label should be used for UI purposes. If the specified representation is not found in this assembly, an empty string is returned.',
                                              'inArgs': ['representation'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The representation type. ',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'representation': ['const',
                                                                                    '&'],
                                                                 'status': ['*']},
                                              'types': {'representation': 'MString'}}],
                              'getRepresentations': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturns an array of the representations managed by the node attached to this function set.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Return representations array. ',
                                                                     'qualifiers': [],
                                                                     'type': 'MStringArray'},
                                                      'returnType': 'MStringArray',
                                                      'static': False,
                                                      'typeQualifiers': {'status': ['*']},
                                                      'types': {}}],
                              'getSubAssemblies': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns a list containing direct children of this assembly that are themselves assemblies, for the currently active representation. The returned list will be empty if there are no assembly children of the currently active representation.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Array of child assemblies. ',
                                                                   'qualifiers': [],
                                                                   'type': 'MObjectArray'},
                                                    'returnType': 'MObjectArray',
                                                    'static': False,
                                                    'typeQualifiers': {'status': ['*']},
                                                    'types': {}}],
                              'getTopLevelAssemblies': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns a list containing top-level assemblies. These are assemblies that are not nested inside another assembly.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': 'MObjectArray'},
                                                         'returnType': 'MObjectArray',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                              'handlesAddEdits': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nDetermines whether the assembly supplies edits to its data, for the node attached to this function set.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'true if the assembly adds edits, false if no edits are added. ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'status': ['*']},
                                                   'types': {}}],
                              'importFile': [{'argInfo': {'fileName': {'doc': 'name of the file from which to import objects ',
                                                                       'type': 'MString'},
                                                          'ignoreVersion': {'doc': 'Boolean to control whether to ignore version when importing a file. ',
                                                                            'type': 'bool'},
                                                          'nameSpace': {'doc': 'optional name of the namespace to use when importing objects. Use NULL for default of no namespace. ',
                                                                        'type': 'char'},
                                                          'preserveReferences': {'doc': 'Boolean to indicate whether the references need to be preserved. ',
                                                                                 'type': 'bool'},
                                                          'type': {'doc': 'if NULL, Maya will try to deduce the type of the file. If not NULL, it must contain a file type to use when importing the file. ',
                                                                   'type': 'char'}},
                                              'args': [('fileName',
                                                        'MString',
                                                        'in'),
                                                       ('type',
                                                        'char',
                                                        'in'),
                                                       ('preserveReferences',
                                                        'bool',
                                                        'in'),
                                                       ('nameSpace',
                                                        'char',
                                                        'in'),
                                                       ('ignoreVersion',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'ignoreVersion': False,
                                                           'nameSpace': None,
                                                           'preserveReferences': False,
                                                           'type': None},
                                              'deprecated': False,
                                              'doc': '\nImport the scene elements from the given file into this assembly. See  MFileIO::importFile()  for more information. All elements imported from the file become members of the assembly. DAG nodes in the imported file that are parented to world are parented to the assembly. DAG nodes in the imported file whose parent is not world keep their existing parenting relationship.',
                                              'inArgs': ['fileName',
                                                         'type',
                                                         'preserveReferences',
                                                         'nameSpace',
                                                         'ignoreVersion'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'fileName': ['const',
                                                                              '&'],
                                                                 'ignoreVersion': [],
                                                                 'nameSpace': ['const',
                                                                               '*'],
                                                                 'preserveReferences': [],
                                                                 'type': ['const',
                                                                          '*']},
                                              'types': {'fileName': 'MString',
                                                        'ignoreVersion': 'bool',
                                                        'nameSpace': 'char',
                                                        'preserveReferences': 'bool',
                                                        'type': 'char'}}],
                              'isActive': [{'argInfo': {'representation': {'doc': 'Representation to query. ',
                                                                           'type': 'MString'}},
                                            'args': [('representation',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nDetermines whether the given representation is the active representation for the node attached to this function set.',
                                            'inArgs': ['representation'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true if the representation is active, false otherwise. ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'representation': ['const',
                                                                                  '&'],
                                                               'status': ['*']},
                                            'types': {'representation': 'MString'}}],
                              'isTopLevel': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns whether this assembly node is a top-level assembly. An assembly node is a top-level assembly if no container in its (possibly empty) chain of nesting parent containers is an assembly. Of course, this includes the trivial case of its immediate parent container being null.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Whether the assembly node is a top-level assembly.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'status': ['*']},
                                              'types': {}}],
                              'postLoad': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nMethod to initialize assemblies after their creation. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'repTypes': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturn the list of representation types that can be created for this assembly node.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Array of representation types. ',
                                                           'qualifiers': [],
                                                           'type': 'MStringArray'},
                                            'returnType': 'MStringArray',
                                            'static': False,
                                            'typeQualifiers': {'status': ['*']},
                                            'types': {}}],
                              'setRepLabel': [{'argInfo': {'label': {'doc': 'New representation label.',
                                                                     'type': 'MString'},
                                                           'representation': {'doc': 'Representation name. ',
                                                                              'type': 'MString'}},
                                               'args': [('representation',
                                                         'MString',
                                                         'in'),
                                                        ('label',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nChange the representation label.',
                                               'inArgs': ['representation',
                                                          'label'],
                                               'inverse': ('getRepLabel',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'label': ['const',
                                                                            '&'],
                                                                  'representation': ['const',
                                                                                     '&']},
                                               'types': {'label': 'MString',
                                                         'representation': 'MString'}}],
                              'setRepName': [{'argInfo': {'newName': {'doc': 'New representation name starting point. ',
                                                                      'type': 'MString'},
                                                          'representation': {'doc': 'Current representation name. ',
                                                                             'type': 'MString'}},
                                              'args': [('representation',
                                                        'MString',
                                                        'in'),
                                                       ('newName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nRename a representation.',
                                              'inArgs': ['representation',
                                                         'newName'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'New representation name. ',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'newName': ['const',
                                                                             '&'],
                                                                 'representation': ['const',
                                                                                    '&'],
                                                                 'status': ['*']},
                                              'types': {'newName': 'MString',
                                                        'representation': 'MString'}}],
                              'supportsEdits': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nDoes this assembly support edit tracking? \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Whether the assembly supports tracking of edits on its nodes',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'status': ['*']},
                                                 'types': {}}],
                              'supportsMemberChanges': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nCan members of the assembly be changed? \n',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Whether the assembly supports changes to its nodes',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'status': ['*']},
                                                         'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nFunction set type. \n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MFn',
                                                                'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}]},
                  'pymelEnums': {}},
  'MFnAttribute': {'enums': {'DisconnectBehavior': {'valueDocs': {'delete': 'Delete array element (array attributes only).',
                                                                  'kDelete': 'Delete array element (array attributes only).',
                                                                  'kNothing': "Do nothing to the attribute's value.",
                                                                  'kReset': 'Reset the attribute to its default.',
                                                                  'nothing': "Do nothing to the attribute's value.",
                                                                  'reset': 'Reset the attribute to its default.'},
                                                    'values': "Enum('DisconnectBehavior', {'kDelete': 0, 'kReset': 1, 'kNothing': 2})"}},
                   'invertibles': [('setConnectable', 'isConnectable'),
                                   ('setUsedAsFilename',
                                    'isUsedAsFilename'),
                                   ('setCached', 'isCached'),
                                   ('setReadable', 'isReadable'),
                                   ('setInternal', 'internal'),
                                   ('setHidden', 'isHidden'),
                                   ('setAffectsAppearance',
                                    'affectsAppearance'),
                                   ('setProxyAttribute',
                                    'isProxyAttribute'),
                                   ('setWorldSpace', 'isWorldSpace'),
                                   ('setKeyable', 'isKeyable'),
                                   ('setAffectsWorldSpace',
                                    'isAffectsWorldSpace'),
                                   ('setRenderSource', 'isRenderSource'),
                                   ('setStorable', 'isStorable'),
                                   ('setUsesArrayDataBuilder',
                                    'usesArrayDataBuilder'),
                                   ('setDisconnectBehavior',
                                    'disconnectBehavior'),
                                   ('setIndeterminant', 'isIndeterminant'),
                                   ('setIndexMatters', 'indexMatters'),
                                   ('setUsedAsColor', 'isUsedAsColor'),
                                   ('setWritable', 'isWritable'),
                                   ('setArray', 'isArray')],
                   'methods': {'accepts': [{'argInfo': {'type': {'doc': 'data type ',
                                                                 'type': ('MFnData',
                                                                          'Type')}},
                                            'args': [('type',
                                                      ('MFnData',
                                                       'Type'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if this attribute can accept a connection of the given type.',
                                            'inArgs': ['type'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A boolean value indicating whether a connection of that type is valid',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'type': []},
                                            'types': {'type': ('MFnData',
                                                               'Type')}},
                                           {'argInfo': {'id': {'doc': 'data type id ',
                                                               'type': 'MTypeId'}},
                                            'args': [('id',
                                                      'MTypeId',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if this attribute can accept a connection of the given type.',
                                            'inArgs': ['id'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A boolean value indicating whether a connection of that type is valid',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'id': ['const',
                                                                      '&']},
                                            'types': {'id': 'MTypeId'}}],
                               'acceptsAttribute': [{'argInfo': {'attr': {'doc': 'attribute ',
                                                                          'type': 'MFnAttribute'}},
                                                     'args': [('attr',
                                                               'MFnAttribute',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns true if this attribute can accept a connection with the given attribute.',
                                                     'inArgs': ['attr'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A boolean value indicating whether a connection with that attribute is valid',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'attr': ['const',
                                                                                 '&']},
                                                     'types': {'attr': 'MFnAttribute'}}],
                               'addToCategory': [{'argInfo': {'category': {'doc': 'New category to which the attribute is to be added ',
                                                                           'type': 'MString'}},
                                                  'args': [('category',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAdd the attribute to the named category. \r\n',
                                                  'inArgs': ['category'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'category': ['const',
                                                                                  '&']},
                                                  'types': {'category': 'MString'}}],
                               'affectsAppearance': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns true if this attribute affects the appearance of the object when rendering in the viewport.',
                                                      'inArgs': [],
                                                      'inverse': ('setAffectsAppearance',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A boolean value indicating whether this attribute affects the appearance of the object when rendering in the viewport.',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClass name. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'disconnectBehavior': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the behavior of this attribute when it is disconnected. The possible settings are as follows:',
                                                       'inArgs': [],
                                                       'inverse': ('setDisconnectBehavior',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The disconnect behavior',
                                                                      'qualifiers': [],
                                                                      'type': ('MFnAttribute',
                                                                               'DisconnectBehavior')},
                                                       'returnType': ('MFnAttribute',
                                                                      'DisconnectBehavior'),
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                               'getAddAttrCmd': [{'argInfo': {'useLongName': {'doc': "if true, use the attribute's long name rather than its short name ",
                                                                              'type': 'bool'}},
                                                  'args': [('useLongName',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'useLongName': False},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns a string containing the  addAttr  command which would be required to recreate the  attribute  on a node. The command includes the terminating semicolon and is formatted as if for use with a selected node, meaning that it contains no node name.',
                                                  'inArgs': ['useLongName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Return status',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': False,
                                                  'typeQualifiers': {'status': ['*'],
                                                                     'useLongName': []},
                                                  'types': {'useLongName': 'bool'}}],
                               'getCategories': [{'argInfo': {'categories': {'doc': 'An MStringArray which will be overwritten with the categories associated with this attribute. ',
                                                                             'type': 'MStringArray'}},
                                                  'args': [('categories',
                                                            'MStringArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet all of the categories to which this attribute belongs. \r\n',
                                                  'inArgs': [],
                                                  'outArgs': ['categories'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'categories': ['&']},
                                                  'types': {'categories': 'MStringArray'}}],
                               'hasCategory': [{'argInfo': {'category': {'doc': 'Category to check for attribute membership ',
                                                                         'type': 'MString'}},
                                                'args': [('category',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCheck to see if the attribute belongs to the named category. \r\n',
                                                'inArgs': ['category'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'True if the attribute belongs to that category ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'category': ['const',
                                                                                '&']},
                                                'types': {'category': 'MString'}}],
                               'indexMatters': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nDetermines whether the user must specify an index when connecting to this attribute, or whether the next available index can be used. This method only applies to array attributes which are non readable, i.e. destination attributes.',
                                                 'inArgs': [],
                                                 'inverse': ('setIndexMatters',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true The user must specify the index when connecting to this attribute using connectAttr  false The next available index can be used when connecting to this attribute using connectAttr -na  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                               'internal': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns true if a node has internal member data representing this attribute.',
                                             'inArgs': [],
                                             'inverse': ('setInternal',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A boolean value indicating whether this attribute uses internal data',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'isAffectsWorldSpace': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns true if this attribute affects worldspace.',
                                                        'inArgs': [],
                                                        'inverse': ('setAffectsWorldSpace',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'A boolean value indicating whether this attribute affects worldspace',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                               'isArray': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if this attribute supports an array of data.',
                                            'inArgs': [],
                                            'inverse': ('setArray',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A boolean value indicating whether this attribute stores an array of data',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                               'isCached': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nReturns true if this attribute is cached locally in the node's data block. The default for this is true. Caching a node locally causes a copy of the attribute value for the node to be cached with the node. This removes the need to traverse through the graph to get the value each time it is requested.",
                                             'inArgs': [],
                                             'inverse': ('setCached',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A boolean value indicating whether this attribute is cached locally',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'isChannelBoxFlagSet': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns true if this attribute has its channel box flag set. Attributes will appear in the channel box if their channel box flag is set or if they are keyable.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'A boolean value indicating the status of the channel box flag on this attribute',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                               'isConnectable': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns true if this attribute accepts dependency graph connections. If it does, then the readable and writable methods will indicate what types of connections are accepted.',
                                                  'inArgs': [],
                                                  'inverse': ('setConnectable',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'A boolean value indicating whether this attribute is connectable',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                               'isDynamic': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns true if this attribute is a dynamic attribute.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A boolean value indicating whether this attribute is dynamic',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'isExtension': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns true if this attribute is an extension attribute.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A boolean value indicating whether this attribute is an extension attribute',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                               'isHidden': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns true if this attribute is to hidden from the UI. The attribute will not show up in attribute editors.',
                                             'inArgs': [],
                                             'inverse': ('setHidden',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A boolean value indicating whether this attribute is hidden',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'isIndeterminant': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns true if this attribute is indeterminant. If an attribute may or may not be used during an evaluation then it is indeterminant. This attribute classification is mainly used on rendering nodes to indicate that some attributes are not always used.',
                                                    'inArgs': [],
                                                    'inverse': ('setIndeterminant',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A boolean value indicating whether this attribute is indeterminant',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                               'isKeyable': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns true if this attribute is keyable. Keyable attributes will be keyed by AutoKey and the Set Keyframe UI. Non-keyable attributes prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.',
                                              'inArgs': [],
                                              'inverse': ('setKeyable',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A boolean value indicating whether this attribute is keyable',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'isProxyAttribute': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns true if this attribute is a proxy attribute.  Parameters: \n \n [out]  ReturnStatus  return status \n \n \n Returns: A boolean value indicating whether this attribute is a proxy attribute \n Status Codes: \n MS::kSuccess  operation successful  \n MS::kFailure  this function set does not have a valid attribute object  \n \n \n',
                                                     'inArgs': [],
                                                     'inverse': ('setProxyAttribute',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A boolean value indicating whether this attribute is a proxy attribute',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                               'isReadable': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns true if this attribute is readable. If an attribute is readable, then it can be used as the source in a dependency graph connection.',
                                               'inArgs': [],
                                               'inverse': ('setReadable',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A boolean value indicating whether this attribute is readable',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                               'isRenderSource': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns true if this attribute is a render source. This attribute is used on rendering nodes to override the rendering sampler info.',
                                                   'inArgs': [],
                                                   'inverse': ('setRenderSource',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'A boolean value indicating whether this attribute is render source',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                               'isStorable': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns true if this attribute is to be stored when the node is saved to a file.',
                                               'inArgs': [],
                                               'inverse': ('setStorable',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A boolean value indicating whether this attribute is storable',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                               'isUsedAsColor': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns true if this attribute is to be presented as a color in the UI.',
                                                  'inArgs': [],
                                                  'inverse': ('setUsedAsColor',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'A boolean value indicating whether this attribute is used as a color',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                               'isUsedAsFilename': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns true if this attribute is to be used as a filename. In the UI this attr will be presented as a file name.',
                                                     'inArgs': [],
                                                     'inverse': ('setUsedAsFilename',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A boolean value indicating whether this attribute is used as a filename',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                               'isWorldSpace': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if this attribute is worldspace.',
                                                 'inArgs': [],
                                                 'inverse': ('setWorldSpace',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A boolean value indicating whether this attribute is worldspace',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                               'isWritable': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns true if this attribute is writable. If an attribute is writable, then it can be used as the destination in a dependency graph connection.',
                                               'inArgs': [],
                                               'inverse': ('setWritable',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A boolean value indicating whether this attribute is writable',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                               'name': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the long name of the attribute. If the attribute has no long name then its short name is returned.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The name of the attribute.',
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                               'parent': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nGet the parent of this attribute, if it has one.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The parent attribute',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                               'removeFromCategory': [{'argInfo': {'category': {'doc': 'Category from which the attribute is to be removed ',
                                                                                'type': 'MString'}},
                                                       'args': [('category',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nRemove the attribute from the named category. \r\n',
                                                       'inArgs': ['category'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'category': ['const',
                                                                                       '&']},
                                                       'types': {'category': 'MString'}}],
                               'setAffectsAppearance': [{'argInfo': {'state': {'doc': 'whether the attribute affects the appearance of the object when rendering in the viewport.',
                                                                               'type': 'bool'}},
                                                         'args': [('state',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets whether this attribute affects the appearance of the object when rendering in the viewport.',
                                                         'inArgs': ['state'],
                                                         'inverse': ('affectsAppearance',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'state': []},
                                                         'types': {'state': 'bool'}}],
                               'setAffectsWorldSpace': [{'argInfo': {'state': {'doc': 'whether the attribute should affect worldspace',
                                                                               'type': 'bool'}},
                                                         'args': [('state',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets whether this attribute should affect worldspace. NOTES: This property is ignored on non-dag nodes.',
                                                         'inArgs': ['state'],
                                                         'inverse': ('isAffectsWorldSpace',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'state': []},
                                                         'types': {'state': 'bool'}}],
                               'setArray': [{'argInfo': {'state': {'doc': 'whether the attribute is to have an array of data',
                                                                   'type': 'bool'}},
                                             'args': [('state',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets whether this attribute should have an array of data. This should be set to true if the attribute needs to accept multiple incoming connections.',
                                             'inArgs': ['state'],
                                             'inverse': ('isArray', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'state': []},
                                             'types': {'state': 'bool'}}],
                               'setCached': [{'argInfo': {'state': {'doc': 'whether the attribute is to be cached locally',
                                                                    'type': 'bool'}},
                                              'args': [('state',
                                                        'bool',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nSets whether the data for this attribute is cached locally in the node's data block. The default for this is true. Caching a node locally causes a copy of the attribute value for the node to be cached with the node. This removes the need to traverse through the graph to get the value each time it is requested. This should only get called in the initialize call of your node creator.",
                                              'inArgs': ['state'],
                                              'inverse': ('isCached',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'state': []},
                                              'types': {'state': 'bool'}}],
                               'setChannelBox': [{'argInfo': {'state': {'doc': 'whether the attribute is to appear in the channel box',
                                                                        'type': 'bool'}},
                                                  'args': [('state',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets whether this attribute should appear in the channel box when the node is selected. This should only get called in the initialize call of your node creator. Keyable attributes are always shown in the channel box so this flag is ignored on keyable attributes. It is for intended for use on non-keyable attributes which you want to appear in the channel box.',
                                                  'inArgs': ['state'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'state': []},
                                                  'types': {'state': 'bool'}}],
                               'setConnectable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be connectable',
                                                                         'type': 'bool'}},
                                                   'args': [('state',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets whether this attribute should allow dependency graph connections. This should only get called in the initialize call of your node creator.',
                                                   'inArgs': ['state'],
                                                   'inverse': ('isConnectable',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'state': []},
                                                   'types': {'state': 'bool'}}],
                               'setDisconnectBehavior': [{'argInfo': {'behavior': {'doc': 'the new disconnect behavior',
                                                                                   'type': ('MFnAttribute',
                                                                                            'DisconnectBehavior')}},
                                                          'args': [('behavior',
                                                                    ('MFnAttribute',
                                                                     'DisconnectBehavior'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSets the disconnection behavior for this attribute. This determines what happens when a connection to this attribute is deleted. This should only get called in the initialize call of your node creator.',
                                                          'inArgs': ['behavior'],
                                                          'inverse': ('disconnectBehavior',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'behavior': []},
                                                          'types': {'behavior': ('MFnAttribute',
                                                                                 'DisconnectBehavior')}}],
                               'setHidden': [{'argInfo': {'state': {'doc': 'whether the attribute is to be hidden',
                                                                    'type': 'bool'}},
                                              'args': [('state',
                                                        'bool',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets whether this attribute should be hidden from the UI. This is useful if the attribute is being used for blind data, or if it is being used as scratch space for a geometry calculation (should also be marked non-connectable in that case).',
                                              'inArgs': ['state'],
                                              'inverse': ('isHidden',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'state': []},
                                              'types': {'state': 'bool'}}],
                               'setIndeterminant': [{'argInfo': {'state': {'doc': 'whether the attribute indeterminant',
                                                                           'type': 'bool'}},
                                                     'args': [('state',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets whether this attribute is indeterminant. If an attribute may or may not be used during an evaluation then it is indeterminant. This attribute classification is mainly used on rendering nodes to indicate that some attributes are not always used.',
                                                     'inArgs': ['state'],
                                                     'inverse': ('isIndeterminant',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'state': []},
                                                     'types': {'state': 'bool'}}],
                               'setIndexMatters': [{'argInfo': {'state': {'doc': "whether the attribute's index must be specified when connecting to this attribute using the connectAttr command",
                                                                          'type': 'bool'}},
                                                    'args': [('state',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nIf the attribute is an array, then this method specifies whether to force the user to specify an index when connecting to this attribute, or to use the next available index.',
                                                    'inArgs': ['state'],
                                                    'inverse': ('indexMatters',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'state': []},
                                                    'types': {'state': 'bool'}}],
                               'setInternal': [{'argInfo': {'state': {'doc': 'whether the attribute uses internal data',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nThe function controls an attribute's data storage. When set to true, the virtual methods  MPxNode::setInternalValue()  and  MPxNode::getInternalValue()  are invoked whenever the attribute value is set or queried, respectively. By default, attributes are not internal.",
                                                'inArgs': ['state'],
                                                'inverse': ('internal',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'state': []},
                                                'types': {'state': 'bool'}}],
                               'setKeyable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be keyable',
                                                                     'type': 'bool'}},
                                               'args': [('state',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets whether this attribute should accept keyframe data. This should only get called in the initialize call of your node creator. Keyable attributes will be keyed by AutoKey and the Set Keyframe UI. Non-keyable attributes prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.',
                                               'inArgs': ['state'],
                                               'inverse': ('isKeyable',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'state': []},
                                               'types': {'state': 'bool'}}],
                               'setNiceNameOverride': [{'argInfo': {'localizedName': {'doc': 'The name to use for the current locale.',
                                                                                      'type': 'MString'}},
                                                        'args': [('localizedName',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the localized string which should be used for this attribute in the UI.',
                                                        'inArgs': ['localizedName'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'localizedName': ['const',
                                                                                             '&']},
                                                        'types': {'localizedName': 'MString'}}],
                               'setProxyAttribute': [{'argInfo': {'state': {'doc': 'whether the attribute is a proxy attribute.',
                                                                            'type': 'bool'}},
                                                      'args': [('state',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets whether this attribute is a proxy attribute.',
                                                      'inArgs': ['state'],
                                                      'inverse': ('isProxyAttribute',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'state': []},
                                                      'types': {'state': 'bool'}}],
                               'setReadable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be readable',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets whether this attribute should be readable. If an attribute is readable, then it can be used as the source in a dependency graph connection.',
                                                'inArgs': ['state'],
                                                'inverse': ('isReadable',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'state': []},
                                                'types': {'state': 'bool'}}],
                               'setRenderSource': [{'argInfo': {'state': {'doc': 'whether the attribute is to be a render source',
                                                                          'type': 'bool'}},
                                                    'args': [('state',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets whether this attribute should be used as a render source attribute. When writing shader plug-ins, it is sometimes useful to be able to modify the sampler info, so upstream shading network can be re- evaluated with different sampler info values.',
                                                    'inArgs': ['state'],
                                                    'inverse': ('isRenderSource',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'state': []},
                                                    'types': {'state': 'bool'}}],
                               'setStorable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be storable',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets whether this attribute should be storable. If an attribute is storable, then it will be writen out when the node is stored to a file. This should only get called in the initialize call of your node creator.',
                                                'inArgs': ['state'],
                                                'inverse': ('isStorable',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'state': []},
                                                'types': {'state': 'bool'}}],
                               'setUsedAsColor': [{'argInfo': {'state': {'doc': 'whether the attribute is to be presented as a color',
                                                                         'type': 'bool'}},
                                                   'args': [('state',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets whether this attribute should be presented as a color in the UI.',
                                                   'inArgs': ['state'],
                                                   'inverse': ('isUsedAsColor',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'state': []},
                                                   'types': {'state': 'bool'}}],
                               'setUsedAsFilename': [{'argInfo': {'state': {'doc': 'whether the attribute is to be presented as a filename',
                                                                            'type': 'bool'}},
                                                      'args': [('state',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets whether this attribute should be presented as a filename in the UI.',
                                                      'inArgs': ['state'],
                                                      'inverse': ('isUsedAsFilename',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'state': []},
                                                      'types': {'state': 'bool'}}],
                               'setUsesArrayDataBuilder': [{'argInfo': {'state': {'doc': 'whether the attribute uses an array data builder',
                                                                                  'type': 'bool'}},
                                                            'args': [('state',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSets whether this attribute uses an array data builder. If true, then the  MArrayDataBuilder  class may be used with this attribute to generate its data. If false,  MArrayDataHandle::builder  will fail.',
                                                            'inArgs': ['state'],
                                                            'inverse': ('usesArrayDataBuilder',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'state': []},
                                                            'types': {'state': 'bool'}}],
                               'setWorldSpace': [{'argInfo': {'state': {'doc': 'whether the attribute is to be presented as worldspace',
                                                                        'type': 'bool'}},
                                                  'args': [('state',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets whether this attribute should be treated as worldspace. Being worldspace indicates the attribute is dependent on the worldSpace transformation of this node, and will be marked dirty by any attribute changes in the hierarchy that affects the worldSpace transformation. The attribute needs to be an array since during instancing there are multiple worldSpace paths to the node & Maya requires one array element per path for worldSpace attributes.',
                                                  'inArgs': ['state'],
                                                  'inverse': ('isWorldSpace',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'state': []},
                                                  'types': {'state': 'bool'}}],
                               'setWritable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be writable',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets whether this attribute should be writable. If an attribute is writable, then it can be used as the destination in a dependency graph connection. If an attribute is not writable then  setAttr  commands will fail to change the attribute.',
                                                'inArgs': ['state'],
                                                'inverse': ('isWritable',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'state': []},
                                                'types': {'state': 'bool'}}],
                               'shortName': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the short name of the attribute. If the attribute has no short name then its long name is returned.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of the attribute.',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'usesArrayDataBuilder': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns true if this attribute uses an array data builder. If so, then the  MArrayDataBuilder  class may be used with this attribute.',
                                                         'inArgs': [],
                                                         'inverse': ('setUsesArrayDataBuilder',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A boolean value indicating whether this attribute uses an array data builder.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}]},
                   'pymelEnums': {'DisconnectBehavior': "Enum('DisconnectBehavior', [('delete', 0), ('kDelete', 0), ('reset', 1), ('kReset', 1), ('nothing', 2), ('kNothing', 2)], multiKeys=True)"},
                   'pymelMethods': {'affectsAppearance': 'getAffectsAppearance',
                                    'disconnectBehavior': 'getDisconnectBehavior',
                                    'indexMatters': 'getIndexMatters',
                                    'internal': 'getInternal',
                                    'usesArrayDataBuilder': 'getUsesArrayDataBuilder'}},
  'MFnBase': {'enums': {},
              'invertibles': [('setObject', 'object')],
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'hasObj': [{'argInfo': {'mtype': {'doc': 'Maya Object type',
                                                            'type': ('MFn',
                                                                     'Type')}},
                                      'args': [('mtype',
                                                ('MFn', 'Type'),
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nDetermines whether or not the Function Set is compatible with the specified Maya Object within the API RTTI system.',
                                      'inArgs': ['mtype'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' true = Compatible  false = Not Compatible   ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'mtype': []},
                                      'types': {'mtype': ('MFn', 'Type')}},
                                     {'argInfo': {'object': {'doc': 'Maya Object to be tested for compatibility',
                                                             'type': 'MObject'}},
                                      'args': [('object',
                                                'MObject',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nDetermines whether or not the Function Set is compatible with the specified Maya Object within the API RTTI system.',
                                      'inArgs': ['object'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' true = Compatible  false = Not Compatible   ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'object': ['const',
                                                                    '&']},
                                      'types': {'object': 'MObject'}}],
                          'object': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturns the  MObject  that is attached to the Function Set.',
                                      'inArgs': [],
                                      'inverse': ('setObject', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'An MObject that references the object to which the Function Set is attached. If the function set is not attached to an MObject, MObject::kNullObj will be returned.',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                          'setObject': [{'argInfo': {'object': {'doc': 'Maya Object which is the target for attachment',
                                                                'type': 'MObject'}},
                                         'args': [('object',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nAttaches the Function Set to the specified Maya Object.',
                                         'inArgs': ['object'],
                                         'inverse': ('object', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'object': ['&']},
                                         'types': {'object': 'MObject'}},
                                        {'argInfo': {'object': {'doc': 'Maya Object which is the target for attachment',
                                                                'type': 'MObject'}},
                                         'args': [('object',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                         'inArgs': ['object'],
                                         'inverse': ('object', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'object': ['const',
                                                                       '&']},
                                         'types': {'object': 'MObject'}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nDetermines the type of the Function Set within the API RTTI system.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': ('MFn',
                                                            'Type')},
                                    'returnType': ('MFn', 'Type'),
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}]},
              'pymelEnums': {},
              'pymelMethods': {'object': 'getObject'}},
  'MFnBlendShapeDeformer': {'enums': {'HistoryLocation': {'valueDocs': {'frontOfChain': 'Pre-Defromation.',
                                                                        'kFrontOfChain': 'Pre-Defromation.',
                                                                        'kNormal': 'Automatic deformation order.',
                                                                        'kOther': 'Other deformation order.',
                                                                        'kPost': 'Post-Deformation.',
                                                                        'normal': 'Automatic deformation order.',
                                                                        'other': 'Other deformation order.',
                                                                        'post': 'Post-Deformation.'},
                                                          'values': "Enum('HistoryLocation', {'kFrontOfChain': 0, 'kNormal': 1, 'kPost': 2, 'kOther': 3})"},
                                      'Origin': {'valueDocs': {'kLocalOrigin': '',
                                                               'kWorldOrigin': '',
                                                               'localOrigin': '',
                                                               'worldOrigin': ''},
                                                 'values': "Enum('Origin', {'kLocalOrigin': 0, 'kWorldOrigin': 1})"},
                                      'TargetType': {'valueDocs': {'kObject': '',
                                                                   'kTangent': '',
                                                                   'object': '',
                                                                   'tangent': ''},
                                                     'values': "Enum('TargetType', {'kObject': 0, 'kTangent': 1})"}},
                            'invertibles': [('setEnvelope', 'envelope'),
                                            ('setOrigin', 'origin'),
                                            ('setWeight', 'weight')],
                            'methods': {'addBaseObject': [{'argInfo': {'object': {'doc': 'new base object',
                                                                                  'type': 'MObject'}},
                                                           'args': [('object',
                                                                     'MObject',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nAdds a new base object to the deformer. This object will be deformed as targets are added for it and the deformation parameters change.',
                                                           'inArgs': ['object'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'object': ['&']},
                                                           'types': {'object': 'MObject'}}],
                                        'addTarget': [{'argInfo': {'baseObject': {'doc': 'base object for the target ',
                                                                                  'type': 'MObject'},
                                                                   'fullWeight': {'doc': 'weight value at which the target is in full effect ',
                                                                                  'type': 'double'},
                                                                   'newTarget': {'doc': 'new target object for the given base ',
                                                                                 'type': 'MObject'},
                                                                   'targetType': {'doc': 'target type for the target',
                                                                                  'type': ('MFnBlendShapeDeformer',
                                                                                           'TargetType')},
                                                                   'weightIndex': {'doc': "weight index to use for target's effect ",
                                                                                   'type': 'int'}},
                                                       'args': [('baseObject',
                                                                 'MObject',
                                                                 'in'),
                                                                ('weightIndex',
                                                                 'int',
                                                                 'in'),
                                                                ('newTarget',
                                                                 'MObject',
                                                                 'in'),
                                                                ('fullWeight',
                                                                 'double',
                                                                 'in'),
                                                                ('targetType',
                                                                 ('MFnBlendShapeDeformer',
                                                                  'TargetType'),
                                                                 'in')],
                                                       'defaults': {'targetType': ('MFnBlendShapeDeformer',
                                                                                   'TargetType',
                                                                                   'kObject')},
                                                       'deprecated': False,
                                                       'doc': "\nAdds a new target object for the given base object. The weight index says which of the deformer's weight values will control this target's affects on the base object. The full weight argument determines at what weight the target is in full effect. If a base object has no other targets and the weight is set to the 'full weight', then the base object will look just like the target object.",
                                                       'inArgs': ['baseObject',
                                                                  'weightIndex',
                                                                  'newTarget',
                                                                  'fullWeight',
                                                                  'targetType'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'baseObject': ['const',
                                                                                         '&'],
                                                                          'fullWeight': [],
                                                                          'newTarget': ['const',
                                                                                        '&'],
                                                                          'targetType': [],
                                                                          'weightIndex': []},
                                                       'types': {'baseObject': 'MObject',
                                                                 'fullWeight': 'double',
                                                                 'newTarget': 'MObject',
                                                                 'targetType': ('MFnBlendShapeDeformer',
                                                                                'TargetType'),
                                                                 'weightIndex': 'int'}},
                                                      {'argInfo': {'baseObject': {'doc': 'base object for the target ',
                                                                                  'type': 'MObject'},
                                                                   'fullWeight': {'doc': 'weight value at which the target is in full effect ',
                                                                                  'type': 'double'},
                                                                   'targetType': {'doc': 'target type for the target',
                                                                                  'type': ('MFnBlendShapeDeformer',
                                                                                           'TargetType')},
                                                                   'weightIndex': {'doc': "weight index to use for target's effect ",
                                                                                   'type': 'int'}},
                                                       'args': [('baseObject',
                                                                 'MObject',
                                                                 'in'),
                                                                ('weightIndex',
                                                                 'int',
                                                                 'in'),
                                                                ('fullWeight',
                                                                 'double',
                                                                 'in'),
                                                                ('targetType',
                                                                 ('MFnBlendShapeDeformer',
                                                                  'TargetType'),
                                                                 'in')],
                                                       'defaults': {'targetType': ('MFnBlendShapeDeformer',
                                                                                   'TargetType',
                                                                                   'kObject')},
                                                       'deprecated': False,
                                                       'doc': "\nAdds a new delta target object for the given base object. The weight index says which of the deformer's weight values will control this target's affects on the base object. The full weight argument determines at what weight the target is in full effect. If a base object has no other targets and the weight is set to the 'full weight', then the base object will look just like the target object.",
                                                       'inArgs': ['baseObject',
                                                                  'weightIndex',
                                                                  'fullWeight',
                                                                  'targetType'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'baseObject': ['const',
                                                                                         '&'],
                                                                          'fullWeight': [],
                                                                          'targetType': [],
                                                                          'weightIndex': []},
                                                       'types': {'baseObject': 'MObject',
                                                                 'fullWeight': 'double',
                                                                 'targetType': ('MFnBlendShapeDeformer',
                                                                                'TargetType'),
                                                                 'weightIndex': 'int'}}],
                                        'create': [{'argInfo': {'baseObject': {'doc': 'a base object for the deformer ',
                                                                               'type': 'MObject'},
                                                                'originSpace': {'doc': 'origin about which to deform ',
                                                                                'type': ('MFnBlendShapeDeformer',
                                                                                         'Origin')}},
                                                    'args': [('baseObject',
                                                              'MObject',
                                                              'in'),
                                                             ('originSpace',
                                                              ('MFnBlendShapeDeformer',
                                                               'Origin'),
                                                              'in')],
                                                    'defaults': {'originSpace': ('MFnBlendShapeDeformer',
                                                                                 'Origin',
                                                                                 'kLocalOrigin')},
                                                    'deprecated': False,
                                                    'doc': '\nCreates a new blend shape deformer in the dependency graph with the specified shape as the baseObject.',
                                                    'inArgs': ['baseObject',
                                                               'originSpace'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A handle to the new deformer',
                                                                   'qualifiers': [],
                                                                   'type': 'MObject'},
                                                    'returnType': 'MObject',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'baseObject': [],
                                                                       'originSpace': []},
                                                    'types': {'baseObject': 'MObject',
                                                              'originSpace': ('MFnBlendShapeDeformer',
                                                                              'Origin')}},
                                                   {'argInfo': {'baseObjects': {'doc': 'base object(s) for the deformer ',
                                                                                'type': 'MObjectArray'},
                                                                'historyLoc': {'doc': "where in the shape's history to place the deformer ",
                                                                               'type': ('MFnBlendShapeDeformer',
                                                                                        'HistoryLocation')},
                                                                'originSpace': {'doc': 'origin about which to deform ',
                                                                                'type': ('MFnBlendShapeDeformer',
                                                                                         'Origin')}},
                                                    'args': [('baseObjects',
                                                              'MObjectArray',
                                                              'in'),
                                                             ('originSpace',
                                                              ('MFnBlendShapeDeformer',
                                                               'Origin'),
                                                              'in'),
                                                             ('historyLoc',
                                                              ('MFnBlendShapeDeformer',
                                                               'HistoryLocation'),
                                                              'in')],
                                                    'defaults': {'historyLoc': ('MFnBlendShapeDeformer',
                                                                                'HistoryLocation',
                                                                                'kNormal'),
                                                                 'originSpace': ('MFnBlendShapeDeformer',
                                                                                 'Origin',
                                                                                 'kLocalOrigin')},
                                                    'deprecated': False,
                                                    'doc': '\nCreates a new blend shape deformer in the dependency graph. This method differs from the other  MFnBlendShapeDeformer::create  in that it allows multiple base shapes to be supplied at create time and it allows the use of the front-of-chain history location, which puts the blendShape ahead of other deformers such as skinning deformers.',
                                                    'inArgs': ['baseObjects',
                                                               'originSpace',
                                                               'historyLoc'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A handle to the new deformer',
                                                                   'qualifiers': [],
                                                                   'type': 'MObject'},
                                                    'returnType': 'MObject',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'baseObjects': ['const',
                                                                                       '&'],
                                                                       'historyLoc': [],
                                                                       'originSpace': []},
                                                    'types': {'baseObjects': 'MObjectArray',
                                                              'historyLoc': ('MFnBlendShapeDeformer',
                                                                             'HistoryLocation'),
                                                              'originSpace': ('MFnBlendShapeDeformer',
                                                                              'Origin')}}],
                                        'envelope': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGets the envelope value of the deformer.',
                                                      'inArgs': [],
                                                      'inverse': ('setEnvelope',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Envelope value',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                        'getBaseObjects': [{'argInfo': {'objects': {'doc': 'storage for the array of base objects',
                                                                                    'type': 'MObjectArray'}},
                                                            'args': [('objects',
                                                                      'MObjectArray',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nGet a list of all of the base objects for this deformer. The objects returned will be the deformed versions of the base objects.',
                                                            'inArgs': [],
                                                            'outArgs': ['objects'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'objects': ['&']},
                                                            'types': {'objects': 'MObjectArray'}}],
                                        'getTargets': [{'argInfo': {'baseObject': {'doc': 'The base shape of interest. ',
                                                                                   'type': 'MObject'},
                                                                    'targetObjects': {'doc': 'Storage for the returned array of target objects.',
                                                                                      'type': 'MObjectArray'},
                                                                    'weightIndex': {'doc': 'The index of the weight attribute. Since the weight indices may be sparse, the weightIndexList method should be used to find the weight indices used by a given blendShape. ',
                                                                                    'type': 'int'}},
                                                        'args': [('baseObject',
                                                                  'MObject',
                                                                  'in'),
                                                                 ('weightIndex',
                                                                  'int',
                                                                  'in'),
                                                                 ('targetObjects',
                                                                  'MObjectArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nGet a list of all of the target objects for the given base object that affect it based on the given weight index.',
                                                        'inArgs': ['baseObject',
                                                                   'weightIndex'],
                                                        'outArgs': ['targetObjects'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'baseObject': [],
                                                                           'targetObjects': ['&'],
                                                                           'weightIndex': []},
                                                        'types': {'baseObject': 'MObject',
                                                                  'targetObjects': 'MObjectArray',
                                                                  'weightIndex': 'int'}}],
                                        'historyLocation': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nGets the history location (deformation order). It defines where to place the deformer node in the chain.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The history location (deformation order)',
                                                                            'qualifiers': [],
                                                                            'type': ('MFnBlendShapeDeformer',
                                                                                     'HistoryLocation')},
                                                             'returnType': ('MFnBlendShapeDeformer',
                                                                            'HistoryLocation'),
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                                             'types': {}}],
                                        'numWeights': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturn the number of weight values that this blend shape deformer has. The number of weight values is equal to the number of targets. Targets are either shapes in the dag or baked data on the blendShape node (when a target shape is deleted).',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The number of weight indices',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                        'origin': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGets the origin space. It defines the point around which the differences in the geometry are calculated.',
                                                    'inArgs': [],
                                                    'inverse': ('setOrigin',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The origin space',
                                                                   'qualifiers': [],
                                                                   'type': ('MFnBlendShapeDeformer',
                                                                            'Origin')},
                                                    'returnType': ('MFnBlendShapeDeformer',
                                                                   'Origin'),
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                        'removeTarget': [{'argInfo': {'baseObject': {'doc': 'base object for the target ',
                                                                                     'type': 'MObject'},
                                                                      'fullWeight': {'doc': 'weight value at which the target is in full effect',
                                                                                     'type': 'double'},
                                                                      'target': {'doc': 'target object for the given base to be removed ',
                                                                                 'type': 'MObject'},
                                                                      'weightIndex': {'doc': 'weight index corresponding to the target ',
                                                                                      'type': 'int'}},
                                                          'args': [('baseObject',
                                                                    'MObject',
                                                                    'in'),
                                                                   ('weightIndex',
                                                                    'int',
                                                                    'in'),
                                                                   ('target',
                                                                    'MObject',
                                                                    'in'),
                                                                   ('fullWeight',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nRemove a target object for the given base object. The weight index specifies the index at which target is connected. The full weight argument specifies at what weight the target is in full effect.',
                                                          'inArgs': ['baseObject',
                                                                     'weightIndex',
                                                                     'target',
                                                                     'fullWeight'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'baseObject': ['const',
                                                                                            '&'],
                                                                             'fullWeight': [],
                                                                             'target': ['const',
                                                                                        '&'],
                                                                             'weightIndex': []},
                                                          'types': {'baseObject': 'MObject',
                                                                    'fullWeight': 'double',
                                                                    'target': 'MObject',
                                                                    'weightIndex': 'int'}}],
                                        'setEnvelope': [{'argInfo': {'envelope': {'doc': 'envelope value',
                                                                                  'type': 'float'}},
                                                         'args': [('envelope',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the envelope value of the deformer.',
                                                         'inArgs': ['envelope'],
                                                         'inverse': ('envelope',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'envelope': []},
                                                         'types': {'envelope': 'float'}}],
                                        'setOrigin': [{'argInfo': {'space': {'doc': 'origin space',
                                                                             'type': ('MFnBlendShapeDeformer',
                                                                                      'Origin')}},
                                                       'args': [('space',
                                                                 ('MFnBlendShapeDeformer',
                                                                  'Origin'),
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets the origin space. It defines the point around which the differences in the geometry are calculated.',
                                                       'inArgs': ['space'],
                                                       'inverse': ('origin',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'space': []},
                                                       'types': {'space': ('MFnBlendShapeDeformer',
                                                                           'Origin')}}],
                                        'setWeight': [{'argInfo': {'index': {'doc': 'index of weight value ',
                                                                             'type': 'uint'},
                                                                   'weight': {'doc': 'new weight value',
                                                                              'type': 'float'}},
                                                       'args': [('index',
                                                                 'uint',
                                                                 'in'),
                                                                ('weight',
                                                                 'float',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSet the weight value at the given index.',
                                                       'inArgs': ['index',
                                                                  'weight'],
                                                       'inverse': ('weight',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'index': ['unsigned'],
                                                                          'weight': []},
                                                       'types': {'index': 'uint',
                                                                 'weight': 'float'}}],
                                        'targetItemIndexList': [{'argInfo': {'baseObject': {'doc': 'The deformed object of interest ',
                                                                                            'type': 'MObject'},
                                                                             'targetItemIndices': {'doc': "'inputTargetItem' array indices of the requested target items.",
                                                                                                   'type': 'MIntArray'},
                                                                             'weightIndex': {'doc': "'weights' array index. ",
                                                                                             'type': 'uint'}},
                                                                 'args': [('weightIndex',
                                                                           'uint',
                                                                           'in'),
                                                                          ('baseObject',
                                                                           'MObject',
                                                                           'in'),
                                                                          ('targetItemIndices',
                                                                           'MIntArray',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nA base object may have more than one target using the same element of the blendShape\'s \'weights\' array. We refer to these as the base object\'s "target items" for that weight index.',
                                                                 'inArgs': ['weightIndex',
                                                                            'baseObject'],
                                                                 'outArgs': ['targetItemIndices'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'baseObject': [],
                                                                                    'targetItemIndices': ['&'],
                                                                                    'weightIndex': ['unsigned']},
                                                                 'types': {'baseObject': 'MObject',
                                                                           'targetItemIndices': 'MIntArray',
                                                                           'weightIndex': 'uint'}}],
                                        'type': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nFunction set type. \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': ('MFn',
                                                                          'Type')},
                                                  'returnType': ('MFn',
                                                                 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                        'weight': [{'argInfo': {'index': {'doc': 'index of weight value ',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet the weight value at the given index. To be valid, a weight value should only be requested at index values returned by  MFnBlendShapeDeformer::weightIndexList .',
                                                    'inArgs': ['index'],
                                                    'inverse': ('setWeight',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The weight value',
                                                                   'qualifiers': [],
                                                                   'type': 'float'},
                                                    'returnType': 'float',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'index': ['unsigned']},
                                                    'types': {'index': 'uint'}}],
                                        'weightIndexList': [{'argInfo': {'indexList': {'doc': 'the array index numbers for the blendShape targets',
                                                                                       'type': 'MIntArray'}},
                                                             'args': [('indexList',
                                                                       'MIntArray',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nReturn the array index numbers corresponding to the targets. The resulting index list will be the length of MFnBlendShape::numWeights. This method exists because the indices of the targets can be sparse. For example, if a target has been removed using Deform -> Edit BlendShape -> Remove.',
                                                             'inArgs': [],
                                                             'outArgs': ['indexList'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'indexList': ['&']},
                                                             'types': {'indexList': 'MIntArray'}}]},
                            'pymelEnums': {'HistoryLocation': "Enum('HistoryLocation', [('frontOfChain', 0), ('kFrontOfChain', 0), ('normal', 1), ('kNormal', 1), ('post', 2), ('kPost', 2), ('other', 3), ('kOther', 3)], multiKeys=True)",
                                           'Origin': "Enum('Origin', [('localOrigin', 0), ('kLocalOrigin', 0), ('worldOrigin', 1), ('kWorldOrigin', 1)], multiKeys=True)",
                                           'TargetType': "Enum('TargetType', [('object', 0), ('kObject', 0), ('tangent', 1), ('kTangent', 1)], multiKeys=True)"},
                            'pymelMethods': {'envelope': 'getEnvelope',
                                             'origin': 'getOrigin',
                                             'weight': 'getWeight'}},
  'MFnBlinnShader': {'enums': {},
                     'invertibles': [('setSpecularRollOff',
                                      'specularRollOff'),
                                     ('setEccentricity', 'eccentricity')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nClass name. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not the new node will be connected to the shader classification node. ',
                                                                       'type': 'bool'}},
                                             'args': [('UIvisible',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'UIvisible': True},
                                             'deprecated': False,
                                             'doc': '\nCreates a new blinn shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.',
                                             'inArgs': ['UIvisible'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'UIvisible': []},
                                             'types': {'UIvisible': 'bool'}}],
                                 'eccentricity': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nRetrieves the value of the "eccentricity" attribute of a blinn shader node. This attribute determines the size of the highlight produced by the shader.',
                                                   'inArgs': [],
                                                   'inverse': ('setEccentricity',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The value of the "eccentricity" attribute of the shader node.',
                                                                  'qualifiers': [],
                                                                  'type': 'float'},
                                                   'returnType': 'float',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                 'setEccentricity': [{'argInfo': {'eccentr': {'doc': 'value to which the attribute will be set.',
                                                                              'type': 'float'}},
                                                      'args': [('eccentr',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets the value of the "eccentricity" attribute of a shader node.',
                                                      'inArgs': ['eccentr'],
                                                      'inverse': ('eccentricity',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'eccentr': ['const',
                                                                                     '&']},
                                                      'types': {'eccentr': 'float'}}],
                                 'setSpecularRollOff': [{'argInfo': {'specular_rolloff': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'float'}},
                                                         'args': [('specular_rolloff',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the value of the "specularRollOff" attribute of a shader node.',
                                                         'inArgs': ['specular_rolloff'],
                                                         'inverse': ('specularRollOff',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'specular_rolloff': ['const',
                                                                                                 '&']},
                                                         'types': {'specular_rolloff': 'float'}}],
                                 'specularRollOff': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nRetrieves the value of the "specularRollOff" attribute of a blinn shader node. This attribute controls the increased oblique angle reflectivity of the shader.',
                                                      'inArgs': [],
                                                      'inverse': ('setSpecularRollOff',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The value of the "specularRollOff" attribute of the shader node.',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'eccentricity': 'getEccentricity',
                                      'specularRollOff': 'getSpecularRollOff'}},
  'MFnCamera': {'enums': {'FilmFit': {'valueDocs': {'fillFilmFit': 'The system calculates both horizontal and vertical fits and then applies the one that makes the digital image larger than the film back.',
                                                    'horizontalFilmFit': 'The digital image is made to fit the film back exactly in the horizontal direction. This then gives each pixel a horizontal size = (film back width) / (horizontal resolution). The pixel height is then = (pixel width) / (pixel aspect ratio). Now that the pixel has a size, resolution gives us a complete image. That image will match the film back exactly in width. It will almost never match in height, either being too tall or too short. By playing with the numbers you can get it pretty close though.',
                                                    'invalid': '',
                                                    'kFillFilmFit': 'The system calculates both horizontal and vertical fits and then applies the one that makes the digital image larger than the film back.',
                                                    'kHorizontalFilmFit': 'The digital image is made to fit the film back exactly in the horizontal direction. This then gives each pixel a horizontal size = (film back width) / (horizontal resolution). The pixel height is then = (pixel width) / (pixel aspect ratio). Now that the pixel has a size, resolution gives us a complete image. That image will match the film back exactly in width. It will almost never match in height, either being too tall or too short. By playing with the numbers you can get it pretty close though.',
                                                    'kInvalid': '',
                                                    'kOverscanFilmFit': 'Over-scanning the film gate in the camera view allows us to choreograph action outside of the frustum from within the camera view without having to resort to a dolly or zoom. This feature is also essential for animating image planes.',
                                                    'kVerticalFilmFit': 'The same idea as horizontal fit, only applied vertically. Thus the digital image will match the film back exactly in height, but miss in width.',
                                                    'overscanFilmFit': 'Over-scanning the film gate in the camera view allows us to choreograph action outside of the frustum from within the camera view without having to resort to a dolly or zoom. This feature is also essential for animating image planes.',
                                                    'verticalFilmFit': 'The same idea as horizontal fit, only applied vertically. Thus the digital image will match the film back exactly in height, but miss in width.'},
                                      'values': "Enum('FilmFit', {'kFillFilmFit': 0, 'kHorizontalFilmFit': 1, 'kVerticalFilmFit': 2, 'kOverscanFilmFit': 3, 'kInvalid': 4})"},
                          'RollOrder': {'valueDocs': {'kRotateTranslate': 'Rotate the film back before translating it by the pivot point.',
                                                      'kTranslateRotate': 'Translate the film back by the pivot point before rotating it.',
                                                      'rotateTranslate': 'Rotate the film back before translating it by the pivot point.',
                                                      'translateRotate': 'Translate the film back by the pivot point before rotating it.'},
                                        'values': "Enum('RollOrder', {'kRotateTranslate': 0, 'kTranslateRotate': 1})"}},
                'invertibles': [('setFarClippingPlane', 'farClippingPlane'),
                                ('setDisplayGateMask', 'isDisplayGateMask'),
                                ('setCameraScale', 'cameraScale'),
                                ('setEyePoint', 'eyePoint'),
                                ('setFarFocusDistance', 'farFocusDistance'),
                                ('setVerticalShake', 'verticalShake'),
                                ('setOrthoWidth', 'orthoWidth'),
                                ('setHorizontalFilmAperture',
                                 'horizontalFilmAperture'),
                                ('setZoom', 'zoom'),
                                ('setVerticalFilmOffset',
                                 'verticalFilmOffset'),
                                ('setVerticalLock', 'isVerticalLock'),
                                ('setLensSqueezeRatio', 'lensSqueezeRatio'),
                                ('setDisplayFilmGate', 'isDisplayFilmGate'),
                                ('setFilmTranslateH', 'filmTranslateH'),
                                ('setFStop', 'fStop'),
                                ('setHorizontalFieldOfView',
                                 'horizontalFieldOfView'),
                                ('setFilmRollOrder', 'filmRollOrder'),
                                ('setFilmTranslateV', 'filmTranslateV'),
                                ('setMotionBlur', 'isMotionBlur'),
                                ('setFilmFit', 'filmFit'),
                                ('setAspectRatio', 'aspectRatio'),
                                ('setFocusDistance', 'focusDistance'),
                                ('setHorizontalRollPivot',
                                 'horizontalRollPivot'),
                                ('setPanZoomEnabled', 'panZoomEnabled'),
                                ('setStereoHITEnabled', 'stereoHITEnabled'),
                                ('setClippingPlanes', 'isClippingPlanes'),
                                ('setCenterOfInterest', 'centerOfInterest'),
                                ('setOverscan', 'overscan'),
                                ('setShakeOverscan', 'shakeOverscan'),
                                ('setHorizontalFilmOffset',
                                 'horizontalFilmOffset'),
                                ('setHorizontalShake', 'horizontalShake'),
                                ('setVerticalFieldOfView',
                                 'verticalFieldOfView'),
                                ('setFilmRollValue', 'filmRollValue'),
                                ('setShakeOverscanEnabled',
                                 'shakeOverscanEnabled'),
                                ('setVerticalRollPivot',
                                 'verticalRollPivot'),
                                ('setTumblePivot', 'tumblePivot'),
                                ('setNearClippingPlane',
                                 'nearClippingPlane'),
                                ('setDepthOfField', 'isDepthOfField'),
                                ('setFocalLength', 'focalLength'),
                                ('setShakeEnabled', 'shakeEnabled'),
                                ('setPreScale', 'preScale'),
                                ('setHorizontalPan', 'horizontalPan'),
                                ('setShutterAngle', 'shutterAngle'),
                                ('setUsePivotAsLocalSpace',
                                 'usePivotAsLocalSpace'),
                                ('setVerticalPan', 'verticalPan'),
                                ('setRenderPanZoom', 'renderPanZoom'),
                                ('setFilmFitOffset', 'filmFitOffset'),
                                ('setIsOrtho', 'isOrtho'),
                                ('setNearFocusDistance',
                                 'nearFocusDistance'),
                                ('setPostScale', 'postScale'),
                                ('setCenterOfInterestPoint',
                                 'centerOfInterestPoint'),
                                ('setStereoHIT', 'stereoHIT'),
                                ('setVerticalFilmAperture',
                                 'verticalFilmAperture')],
                'methods': {'aspectRatio': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the aspect ratio for the camera.',
                                             'inArgs': [],
                                             'inverse': ('setAspectRatio',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The aspect ratio',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                            'cameraScale': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the camera scale.',
                                             'inArgs': [],
                                             'inverse': ('setCameraScale',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The scale value of the camera',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                            'centerOfInterest': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nReturn the linear distance from the camera's eye point to the center of interest.",
                                                  'inArgs': [],
                                                  'inverse': ('setCenterOfInterest',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'center of interest distance value',
                                                                 'qualifiers': [],
                                                                 'type': 'double',
                                                                 'unitType': u'linear'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                            'centerOfInterestPoint': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                             'type': ('MSpace',
                                                                                      'Space')}},
                                                       'args': [('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject')},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the center of interest point for the camera.',
                                                       'inArgs': ['space'],
                                                       'inverse': ('setCenterOfInterestPoint',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The center of interest location of the camera',
                                                                      'qualifiers': [],
                                                                      'type': 'MPoint'},
                                                       'returnType': 'MPoint',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'space': []},
                                                       'types': {'space': ('MSpace',
                                                                           'Space')}}],
                            'computeDepthOfField': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\n Returns: Status code \n Status Codes: \n MS::kSuccess  The method was successful  \n MS::kFailure  An object error has occurred  \n \n \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}},
                                                    {'argInfo': {'nearLimit': {'doc': '',
                                                                               'type': 'double'}},
                                                     'args': [('nearLimit',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\n Parameters: \n \n [in]  nearLimit  \n \n \n Returns: Status code \n Status Codes: \n MS::kSuccess  The method was successful  \n MS::kFailure  An object error has occurred  \n \n \n',
                                                     'inArgs': ['nearLimit'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'nearLimit': []},
                                                     'types': {'nearLimit': 'double'}}],
                            'copyViewFrom': [{'argInfo': {'otherCamera': {'doc': 'Camera to copy view from',
                                                                          'type': 'MDagPath'}},
                                              'args': [('otherCamera',
                                                        'MDagPath',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nCopy the camera settings related to the perspective from the given camera view.',
                                              'inArgs': ['otherCamera'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'otherCamera': ['const',
                                                                                 '&']},
                                              'types': {'otherCamera': 'MDagPath'}}],
                            'create': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCreates a perspective camera and a transform to parent it.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The transform parenting the new camera',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}},
                                       {'argInfo': {'parent': {'doc': 'The parent of the new camera ',
                                                               'type': 'MObject'}},
                                        'args': [('parent',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCreates a perspective camera. A parent can be specified for the new camera, otherwise a transform is created.',
                                        'inArgs': ['parent'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The transform parenting the new camera',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           'parent': ['&']},
                                        'types': {'parent': 'MObject'}}],
                            'eyePoint': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                'type': ('MSpace',
                                                                         'Space')}},
                                          'args': [('space',
                                                    ('MSpace', 'Space'),
                                                    'in')],
                                          'defaults': {'space': ('MSpace',
                                                                 'Space',
                                                                 'kObject')},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the eye point for the camera.',
                                          'inArgs': ['space'],
                                          'inverse': ('setEyePoint',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The eye point location for the camera',
                                                         'qualifiers': [],
                                                         'type': 'MPoint'},
                                          'returnType': 'MPoint',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'space': []},
                                          'types': {'space': ('MSpace',
                                                              'Space')}}],
                            'fStop': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns the f-stop value for the camera.',
                                       'inArgs': [],
                                       'inverse': ('setFStop', False),
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The F/Stop value for the camera',
                                                      'qualifiers': [],
                                                      'type': 'double'},
                                       'returnType': 'double',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                            'farClippingPlane': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the distance to the far clipping plane.',
                                                  'inArgs': [],
                                                  'inverse': ('setFarClippingPlane',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The far clipping plane value for the camera',
                                                                 'qualifiers': [],
                                                                 'type': 'double',
                                                                 'unitType': u'linear'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                            'farFocusDistance': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the linear distance to the far focus plane.',
                                                  'inArgs': [],
                                                  'inverse': ('setFarFocusDistance',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The far focus distance for the camera',
                                                                 'qualifiers': [],
                                                                 'type': 'double',
                                                                 'unitType': u'linear'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                            'filmFit': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns how the digital image is being fitted to the film back.',
                                         'inArgs': [],
                                         'inverse': ('setFilmFit', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The type of film fit.',
                                                        'qualifiers': [],
                                                        'type': ('MFnCamera',
                                                                 'FilmFit')},
                                         'returnType': ('MFnCamera',
                                                        'FilmFit'),
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                            'filmFitOffset': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the film fit offset for the camera.',
                                               'inArgs': [],
                                               'inverse': ('setFilmFitOffset',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The film fit offset as double.',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'filmRollOrder': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the current roll order',
                                               'inArgs': [],
                                               'inverse': ('setFilmRollOrder',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The roll order',
                                                              'qualifiers': [],
                                                              'type': ('MFnCamera',
                                                                       'RollOrder')},
                                               'returnType': ('MFnCamera',
                                                              'RollOrder'),
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'filmRollValue': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the current roll value in radians.',
                                               'inArgs': [],
                                               'inverse': ('setFilmRollValue',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Roll value in radians.',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'filmTranslateH': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the horizontal film translate value. This value corresponds to the normalized viewport.',
                                                'inArgs': [],
                                                'inverse': ('setFilmTranslateH',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The horizontal translation amount.',
                                                               'qualifiers': [],
                                                               'type': 'double'},
                                                'returnType': 'double',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                            'filmTranslateV': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the vertical film translate value. This value corresponds to the normalized viewport, [-1,1].',
                                                'inArgs': [],
                                                'inverse': ('setFilmTranslateV',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The vertical film translation.',
                                                               'qualifiers': [],
                                                               'type': 'double'},
                                                'returnType': 'double',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                            'focalLength': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the focal length for the camera.',
                                             'inArgs': [],
                                             'inverse': ('setFocalLength',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The focal length for the camera',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                            'focusDistance': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the focus distance for the camera. This value sets the focus at a certain distance in front of the camera.',
                                               'inArgs': [],
                                               'inverse': ('setFocusDistance',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The focus distance for the camera',
                                                              'qualifiers': [],
                                                              'type': 'double',
                                                              'unitType': u'linear'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'getAspectRatioLimits': [{'argInfo': {'max': {'doc': 'Storage for the maximum aspect ratio limit',
                                                                          'type': 'double'},
                                                                  'min': {'doc': 'Storage for the minimum aspect ratio limit ',
                                                                          'type': 'double'}},
                                                      'args': [('min',
                                                                'double',
                                                                'out'),
                                                               ('max',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the minimum and maximum aspect ratio limits for the camera.',
                                                      'inArgs': [],
                                                      'outArgs': ['min',
                                                                  'max'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'max': ['&'],
                                                                         'min': ['&']},
                                                      'types': {'max': 'double',
                                                                'min': 'double'}}],
                            'getFilmApertureLimits': [{'argInfo': {'max': {'doc': 'Storage for the maximum film aperture limit',
                                                                           'type': 'double'},
                                                                   'min': {'doc': 'Storage for the minimum film aperture limit ',
                                                                           'type': 'double'}},
                                                       'args': [('min',
                                                                 'double',
                                                                 'out'),
                                                                ('max',
                                                                 'double',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the maximum and minimum film aperture limits for the camera.',
                                                       'inArgs': [],
                                                       'outArgs': ['min',
                                                                   'max'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'max': ['&'],
                                                                          'min': ['&']},
                                                       'types': {'max': 'double',
                                                                 'min': 'double'}}],
                            'getFilmFrustum': [{'argInfo': {'applyPanZoom': {'doc': 'specifies whether to apply 2D pan/zoom',
                                                                             'type': 'bool'},
                                                            'distance': {'doc': 'Specifies the focal length ',
                                                                         'type': 'double',
                                                                         'unitType': u'linear'},
                                                            'hOffset': {'doc': 'storage for horizontal offset ',
                                                                        'type': 'double'},
                                                            'hSize': {'doc': 'storage for horizontal size ',
                                                                      'type': 'double'},
                                                            'vOffset': {'doc': 'storage for vertical offset ',
                                                                        'type': 'double'},
                                                            'vSize': {'doc': 'storage for vertical size ',
                                                                      'type': 'double'}},
                                                'args': [('distance',
                                                          'double',
                                                          'in'),
                                                         ('hSize',
                                                          'double',
                                                          'out'),
                                                         ('vSize',
                                                          'double',
                                                          'out'),
                                                         ('hOffset',
                                                          'double',
                                                          'out'),
                                                         ('vOffset',
                                                          'double',
                                                          'out'),
                                                         ('applyPanZoom',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'applyPanZoom': False},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the film frustum for the camera. The frustum defines the projective transformation.',
                                                'inArgs': ['distance',
                                                           'applyPanZoom'],
                                                'outArgs': ['hSize',
                                                            'vSize',
                                                            'hOffset',
                                                            'vOffset'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'applyPanZoom': [],
                                                                   'distance': [],
                                                                   'hOffset': ['&'],
                                                                   'hSize': ['&'],
                                                                   'vOffset': ['&'],
                                                                   'vSize': ['&']},
                                                'types': {'applyPanZoom': 'bool',
                                                          'distance': 'double',
                                                          'hOffset': 'double',
                                                          'hSize': 'double',
                                                          'vOffset': 'double',
                                                          'vSize': 'double'}},
                                               {'argInfo': {'applyPanZoom': {'doc': 'specifies whether to apply 2D pan/zoom',
                                                                             'type': 'bool'},
                                                            'clipPlane': {'doc': 'Storage for the film frustum (allocated by user) ',
                                                                          'type': 'MPoint__array4'},
                                                            'distance': {'doc': 'Specifies the focal length ',
                                                                         'type': 'double',
                                                                         'unitType': u'linear'}},
                                                'args': [('distance',
                                                          'double',
                                                          'in'),
                                                         ('clipPlane',
                                                          'MPoint__array4',
                                                          'out'),
                                                         ('applyPanZoom',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'applyPanZoom': False},
                                                'deprecated': False,
                                                'doc': '\r\nNo script support. \r\n',
                                                'inArgs': ['distance',
                                                           'applyPanZoom'],
                                                'outArgs': ['clipPlane'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'applyPanZoom': [],
                                                                   'clipPlane': [],
                                                                   'distance': []},
                                                'types': {'applyPanZoom': 'bool',
                                                          'clipPlane': 'MPoint__array4',
                                                          'distance': 'double'}}],
                            'getFocalLengthLimits': [{'argInfo': {'max': {'doc': 'Storage for the maximum focal length limit',
                                                                          'type': 'double'},
                                                                  'min': {'doc': 'Storage for the minimum focal length limit ',
                                                                          'type': 'double'}},
                                                      'args': [('min',
                                                                'double',
                                                                'out'),
                                                               ('max',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the focal length limits for the camera.',
                                                      'inArgs': [],
                                                      'outArgs': ['min',
                                                                  'max'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'max': ['&'],
                                                                         'min': ['&']},
                                                      'types': {'max': 'double',
                                                                'min': 'double'}}],
                            'getPortFieldOfView': [{'argInfo': {'height': {'doc': 'height of viewport ',
                                                                           'type': 'int'},
                                                                'horizontalFOV': {'doc': 'storage for the horizonal field of view ',
                                                                                  'type': 'double',
                                                                                  'unitType': u'angular'},
                                                                'verticalFOV': {'doc': 'storage for the vertical field of view',
                                                                                'type': 'double',
                                                                                'unitType': u'angular'},
                                                                'width': {'doc': 'width of viewport ',
                                                                          'type': 'int'}},
                                                    'args': [('width',
                                                              'int',
                                                              'in'),
                                                             ('height',
                                                              'int',
                                                              'in'),
                                                             ('horizontalFOV',
                                                              'double',
                                                              'out'),
                                                             ('verticalFOV',
                                                              'double',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nCompute the horizontal and vertical field of view in radians from the given viewport width and height.',
                                                    'inArgs': ['width',
                                                               'height'],
                                                    'outArgs': ['horizontalFOV',
                                                                'verticalFOV'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'height': [],
                                                                       'horizontalFOV': ['&'],
                                                                       'verticalFOV': ['&'],
                                                                       'width': []},
                                                    'types': {'height': 'int',
                                                              'horizontalFOV': 'double',
                                                              'verticalFOV': 'double',
                                                              'width': 'int'}}],
                            'getRenderingFrustum': [{'argInfo': {'bottom': {'doc': 'storage for the bottom of frustum ',
                                                                            'type': 'double'},
                                                                 'left': {'doc': 'storage for the left side of frustum ',
                                                                          'type': 'double'},
                                                                 'right': {'doc': 'storage for the right side of frustum ',
                                                                           'type': 'double'},
                                                                 'top': {'doc': 'storage for the top of frustum',
                                                                         'type': 'double'},
                                                                 'windowAspect': {'doc': 'windowAspect ',
                                                                                  'type': 'double'}},
                                                     'args': [('windowAspect',
                                                               'double',
                                                               'in'),
                                                              ('left',
                                                               'double',
                                                               'out'),
                                                              ('right',
                                                               'double',
                                                               'out'),
                                                              ('bottom',
                                                               'double',
                                                               'out'),
                                                              ('top',
                                                               'double',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nComputes and returns the rendering frustum for the camera. This is the frustum that the maya renderer uses.',
                                                     'inArgs': ['windowAspect'],
                                                     'outArgs': ['left',
                                                                 'right',
                                                                 'bottom',
                                                                 'top'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'bottom': ['&'],
                                                                        'left': ['&'],
                                                                        'right': ['&'],
                                                                        'top': ['&'],
                                                                        'windowAspect': []},
                                                     'types': {'bottom': 'double',
                                                               'left': 'double',
                                                               'right': 'double',
                                                               'top': 'double',
                                                               'windowAspect': 'double'}}],
                            'getViewParameters': [{'argInfo': {'apertureX': {'doc': 'storage for the horizontal aperture ',
                                                                             'type': 'double'},
                                                               'apertureY': {'doc': 'storage for the vertical aperture ',
                                                                             'type': 'double'},
                                                               'applyOverscan': {'doc': 'specifies whether to apply overscan ',
                                                                                 'type': 'bool'},
                                                               'applyPanZoom': {'doc': 'specifies whether to apply 2D pan/zoom',
                                                                                'type': 'bool'},
                                                               'applySqueeze': {'doc': 'specifies whether to apply the lens squeeze ratio of the camera ',
                                                                                'type': 'bool'},
                                                               'offsetX': {'doc': 'storage for the horizontal offset ',
                                                                           'type': 'double'},
                                                               'offsetY': {'doc': 'storage for the vertical offset ',
                                                                           'type': 'double'},
                                                               'windowAspect': {'doc': 'windowAspect ',
                                                                                'type': 'double'}},
                                                   'args': [('windowAspect',
                                                             'double',
                                                             'in'),
                                                            ('apertureX',
                                                             'double',
                                                             'out'),
                                                            ('apertureY',
                                                             'double',
                                                             'out'),
                                                            ('offsetX',
                                                             'double',
                                                             'out'),
                                                            ('offsetY',
                                                             'double',
                                                             'out'),
                                                            ('applyOverscan',
                                                             'bool',
                                                             'in'),
                                                            ('applySqueeze',
                                                             'bool',
                                                             'in'),
                                                            ('applyPanZoom',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'applyOverscan': False,
                                                                'applyPanZoom': False,
                                                                'applySqueeze': False},
                                                   'deprecated': False,
                                                   'doc': '\r\nComputes and returns the intermediate viewing frustum parameters for the camera. The aperture and offset are used by getViewingFrustrum() and getRenderingFrustrum() to compute the extent (left, right, top, bottom) of the frustrum in the following manner:',
                                                   'inArgs': ['windowAspect',
                                                              'applyOverscan',
                                                              'applySqueeze',
                                                              'applyPanZoom'],
                                                   'outArgs': ['apertureX',
                                                               'apertureY',
                                                               'offsetX',
                                                               'offsetY'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'apertureX': ['&'],
                                                                      'apertureY': ['&'],
                                                                      'applyOverscan': [],
                                                                      'applyPanZoom': [],
                                                                      'applySqueeze': [],
                                                                      'offsetX': ['&'],
                                                                      'offsetY': ['&'],
                                                                      'windowAspect': []},
                                                   'types': {'apertureX': 'double',
                                                             'apertureY': 'double',
                                                             'applyOverscan': 'bool',
                                                             'applyPanZoom': 'bool',
                                                             'applySqueeze': 'bool',
                                                             'offsetX': 'double',
                                                             'offsetY': 'double',
                                                             'windowAspect': 'double'}}],
                            'getViewingFrustum': [{'argInfo': {'applyOverscan': {'doc': 'specifies whether to apply overscan ',
                                                                                 'type': 'bool'},
                                                               'applyPanZoom': {'doc': 'specifies whether to apply 2D pan/zoom',
                                                                                'type': 'bool'},
                                                               'applySqueeze': {'doc': 'specifies whether to apply the lens squeeze ratio of the camera ',
                                                                                'type': 'bool'},
                                                               'bottom': {'doc': 'storage for the bottom of frustum ',
                                                                          'type': 'double'},
                                                               'left': {'doc': 'storage for the left side of frustum ',
                                                                        'type': 'double'},
                                                               'right': {'doc': 'storage for the right side of frustum ',
                                                                         'type': 'double'},
                                                               'top': {'doc': 'storage for the top of frustum ',
                                                                       'type': 'double'},
                                                               'windowAspect': {'doc': 'windowAspect ',
                                                                                'type': 'double'}},
                                                   'args': [('windowAspect',
                                                             'double',
                                                             'in'),
                                                            ('left',
                                                             'double',
                                                             'out'),
                                                            ('right',
                                                             'double',
                                                             'out'),
                                                            ('bottom',
                                                             'double',
                                                             'out'),
                                                            ('top',
                                                             'double',
                                                             'out'),
                                                            ('applyOverscan',
                                                             'bool',
                                                             'in'),
                                                            ('applySqueeze',
                                                             'bool',
                                                             'in'),
                                                            ('applyPanZoom',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'applyOverscan': False,
                                                                'applyPanZoom': False,
                                                                'applySqueeze': False},
                                                   'deprecated': False,
                                                   'doc': '\r\nComputes and returns the viewing frustum for the camera.',
                                                   'inArgs': ['windowAspect',
                                                              'applyOverscan',
                                                              'applySqueeze',
                                                              'applyPanZoom'],
                                                   'outArgs': ['left',
                                                               'right',
                                                               'bottom',
                                                               'top'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'applyOverscan': [],
                                                                      'applyPanZoom': [],
                                                                      'applySqueeze': [],
                                                                      'bottom': ['&'],
                                                                      'left': ['&'],
                                                                      'right': ['&'],
                                                                      'top': ['&'],
                                                                      'windowAspect': []},
                                                   'types': {'applyOverscan': 'bool',
                                                             'applyPanZoom': 'bool',
                                                             'applySqueeze': 'bool',
                                                             'bottom': 'double',
                                                             'left': 'double',
                                                             'right': 'double',
                                                             'top': 'double',
                                                             'windowAspect': 'double'}}],
                            'hasSamePerspective': [{'argInfo': {'otherCamera': {'doc': 'Camera to compare perspective with ',
                                                                                'type': 'MDagPath'}},
                                                    'args': [('otherCamera',
                                                              'MDagPath',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns true if the camera has same perspective settings as the given camera.',
                                                    'inArgs': ['otherCamera'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True if the specified camera has same perspective as this camera, false otherwise.',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'otherCamera': ['const',
                                                                                       '&']},
                                                    'types': {'otherCamera': 'MDagPath'}}],
                            'horizontalFieldOfView': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the horizontal field of view for the camera.',
                                                       'inArgs': [],
                                                       'inverse': ('setHorizontalFieldOfView',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The horizontal field of view for the camera',
                                                                      'qualifiers': [],
                                                                      'type': 'double',
                                                                      'unitType': u'angular'},
                                                       'returnType': 'double',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                            'horizontalFilmAperture': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the horizontal film aperture for the camera.',
                                                        'inArgs': [],
                                                        'inverse': ('setHorizontalFilmAperture',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The horizontal film aperture for the camera',
                                                                       'qualifiers': [],
                                                                       'type': 'double'},
                                                        'returnType': 'double',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                            'horizontalFilmOffset': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the horizontal offset of the film. Unit used is inches.',
                                                      'inArgs': [],
                                                      'inverse': ('setHorizontalFilmOffset',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The horizontal film offset for the camera',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                            'horizontalPan': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the camera 2D horizontal pan value. Unit is inches.',
                                               'inArgs': [],
                                               'inverse': ('setHorizontalPan',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The camera 2D horizontal pan value',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'horizontalRollPivot': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the current horizontal roll pivot value.',
                                                     'inArgs': [],
                                                     'inverse': ('setHorizontalRollPivot',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The horizontal roll pivot value.',
                                                                    'qualifiers': [],
                                                                    'type': 'double',
                                                                    'unitType': u'linear'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                            'horizontalShake': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the horizontal offset of the film due to the shake attribute. Unit used is inches. This horizontal/vertical attribute pair acts identically to the film offset pair, but gives another point of input to that system. This allows film-based camera shake to be accessed conveniently and independently without disturbing any other film-offsetting techniques.',
                                                 'inArgs': [],
                                                 'inverse': ('setHorizontalShake',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The horizontal film-based camera shake offset for the camera',
                                                                'qualifiers': [],
                                                                'type': 'double'},
                                                 'returnType': 'double',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                            'isClippingPlanes': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermines whether manual clipping planes are activated.',
                                                  'inArgs': [],
                                                  'inverse': ('setClippingPlanes',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'True if the manual clipping planes are activated, false otherwise.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                            'isDepthOfField': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines whether the depth of field calculation is performed for the camera. The depth of field calculation is used to give varying focus depending on the distance of the objects.',
                                                'inArgs': [],
                                                'inverse': ('setDepthOfField',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'True if the depth of field is on, false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                            'isDisplayFilmGate': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines if the film gate icons are displayed when looking through the camera.',
                                                   'inArgs': [],
                                                   'inverse': ('setDisplayFilmGate',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if the film gate is displayed, false otherwise.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                            'isDisplayGateMask': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines if the film gate is displayed shaded.',
                                                   'inArgs': [],
                                                   'inverse': ('setDisplayGateMask',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if the film gate is shaded, false otherwise.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                            'isMotionBlur': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermine if motion blur is on/off for the camera.',
                                              'inArgs': [],
                                              'inverse': ('setMotionBlur',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'True if the motion blur is on, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                            'isOrtho': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nDetermines if the camera is in orthographic mode.',
                                         'inArgs': [],
                                         'inverse': ('setIsOrtho', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'True if the camera is orthographic, false otherwise.',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                            'isVerticalLock': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines if vertical lock is turned on for the camera.',
                                                'inArgs': [],
                                                'inverse': ('setVerticalLock',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'True if the vertical lock is on, false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                            'lensSqueezeRatio': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the lens squeeze ratio for the camera.',
                                                  'inArgs': [],
                                                  'inverse': ('setLensSqueezeRatio',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The lens squeeze ratio for the camera',
                                                                 'qualifiers': [],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                            'nearClippingPlane': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the distance to the near clipping plane.',
                                                   'inArgs': [],
                                                   'inverse': ('setNearClippingPlane',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The near clipping plane value for the camera',
                                                                  'qualifiers': [],
                                                                  'type': 'double',
                                                                  'unitType': u'linear'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                            'nearFocusDistance': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the linear distance to the near focus plane.',
                                                   'inArgs': [],
                                                   'inverse': ('setNearFocusDistance',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The near focus distance for the camera',
                                                                  'qualifiers': [],
                                                                  'type': 'double',
                                                                  'unitType': u'linear'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                            'orthoWidth': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the orthographic projection width.',
                                            'inArgs': [],
                                            'inverse': ('setOrthoWidth',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The orthographic width',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                            'overscan': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the percent of overscan for this camera.',
                                          'inArgs': [],
                                          'inverse': ('setOverscan',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The percent of overscan',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                            'panZoomEnabled': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the toggle value for the camera 2D pan/zoom enabled attribute. If this attribute is false, the 2D pan/zoom values are ignored by the camera.',
                                                'inArgs': [],
                                                'inverse': ('setPanZoomEnabled',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The camera 2D pan/zoom toggle value for the camera',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                            'postProjectionMatrix': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the post projection matrix used to compute film roll on the film back plane.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The film roll matrix.',
                                                                     'qualifiers': [],
                                                                     'type': 'MFloatMatrix'},
                                                      'returnType': 'MFloatMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}},
                                                     {'argInfo': {'context': {'doc': 'DG time-context to specify time of evaluation ',
                                                                              'type': 'MDGContext'}},
                                                      'args': [('context',
                                                                'MDGContext',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the post projection matrix used to compute film roll on the film back plane.',
                                                      'inArgs': ['context'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The film roll matrix.',
                                                                     'qualifiers': [],
                                                                     'type': 'MFloatMatrix'},
                                                      'returnType': 'MFloatMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'context': ['const',
                                                                                     '&']},
                                                      'types': {'context': 'MDGContext'}}],
                            'postScale': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\r\nReturn the post projection matrix's post-scale value.",
                                           'inArgs': [],
                                           'inverse': ('setPostScale',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Post scale value.',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                            'preScale': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nReturn the post projection matrix's pre-scale value.",
                                          'inArgs': [],
                                          'inverse': ('setPreScale',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Pre scale value.',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                            'projectionMatrix': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nReturns the orthographic or perspective projection matrix for the camera. The projection matrix that maya's software renderer uses is almost identical to the OpenGL projection matrix. The difference is that maya uses a left hand coordinate system and so the entries [2][2] and [3][2] are negated.",
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The projection matrix',
                                                                 'qualifiers': [],
                                                                 'type': 'MFloatMatrix'},
                                                  'returnType': 'MFloatMatrix',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}},
                                                 {'argInfo': {'context': {'doc': 'DG time-context to specify time of evaluation. ',
                                                                          'type': 'MDGContext'}},
                                                  'args': [('context',
                                                            'MDGContext',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the orthographic or perspective projection matrix for the camera.',
                                                  'inArgs': ['context'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The projection matrix',
                                                                 'qualifiers': [],
                                                                 'type': 'MFloatMatrix'},
                                                  'returnType': 'MFloatMatrix',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'context': ['const',
                                                                                 '&']},
                                                  'types': {'context': 'MDGContext'}}],
                            'renderPanZoom': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the toggle value for the camera render 2D pan/zoom attribute. If this attribute is false, the 2D pan/zoom values will not affect the output render.',
                                               'inArgs': [],
                                               'inverse': ('setRenderPanZoom',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The camera render 2D pan/zoom toggle value',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'rightDirection': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the right direction vector for the camera.',
                                                'inArgs': ['space'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The right direction vector for the camera',
                                                               'qualifiers': [],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'space': []},
                                                'types': {'space': ('MSpace',
                                                                    'Space')}}],
                            'set': [{'argInfo': {'aspectRatio': {'doc': 'The aspect ratio to set',
                                                                 'type': 'double'},
                                                 'horizFieldOfView': {'doc': 'The horizontal field of view to set ',
                                                                      'type': 'double'},
                                                 'wsEyeLocation': {'doc': 'Eye location to set in world space ',
                                                                   'type': 'MPoint'},
                                                 'wsUpDirection': {'doc': 'Up direction to set in world space ',
                                                                   'type': 'MVector'},
                                                 'wsViewDirection': {'doc': 'View direction to set in world space ',
                                                                     'type': 'MVector'}},
                                     'args': [('wsEyeLocation',
                                               'MPoint',
                                               'in'),
                                              ('wsViewDirection',
                                               'MVector',
                                               'in'),
                                              ('wsUpDirection',
                                               'MVector',
                                               'in'),
                                              ('horizFieldOfView',
                                               'double',
                                               'in'),
                                              ('aspectRatio',
                                               'double',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nConvenience routine to set the camera viewing parameters. The specified values should be in world space where applicable.',
                                     'inArgs': ['wsEyeLocation',
                                                'wsViewDirection',
                                                'wsUpDirection',
                                                'horizFieldOfView',
                                                'aspectRatio'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'aspectRatio': [],
                                                        'horizFieldOfView': [],
                                                        'wsEyeLocation': ['const',
                                                                          '&'],
                                                        'wsUpDirection': ['const',
                                                                          '&'],
                                                        'wsViewDirection': ['const',
                                                                            '&']},
                                     'types': {'aspectRatio': 'double',
                                               'horizFieldOfView': 'double',
                                               'wsEyeLocation': 'MPoint',
                                               'wsUpDirection': 'MVector',
                                               'wsViewDirection': 'MVector'}}],
                            'setAspectRatio': [{'argInfo': {'aspectRatio': {'doc': 'The aspect ratio to be set',
                                                                            'type': 'double'}},
                                                'args': [('aspectRatio',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nSet the aspect ratio of the View. The aspect ratio is expressed as width/height. This also modifies the entity's scale transformation to reflect the new aspect ratio.",
                                                'inArgs': ['aspectRatio'],
                                                'inverse': ('aspectRatio',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'aspectRatio': []},
                                                'types': {'aspectRatio': 'double'}}],
                            'setCameraScale': [{'argInfo': {'scale': {'doc': 'The camera scale value to be set',
                                                                      'type': 'double'}},
                                                'args': [('scale',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the camera scale.',
                                                'inArgs': ['scale'],
                                                'inverse': ('cameraScale',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'scale': []},
                                                'types': {'scale': 'double'}}],
                            'setCenterOfInterest': [{'argInfo': {'dist': {'doc': 'center of interest distance value',
                                                                          'type': 'double',
                                                                          'unitType': u'linear'}},
                                                     'args': [('dist',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the Center of Interest, which is defined to be a positive distance along the View Direction (i.e., "in front" of the Camera).',
                                                     'inArgs': ['dist'],
                                                     'inverse': ('centerOfInterest',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'dist': []},
                                                     'types': {'dist': 'double'}}],
                            'setCenterOfInterestPoint': [{'argInfo': {'centerOfInterest': {'doc': 'Center of interest point to be set ',
                                                                                           'type': 'MPoint'},
                                                                      'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                                'type': ('MSpace',
                                                                                         'Space')}},
                                                          'args': [('centerOfInterest',
                                                                    'MPoint',
                                                                    'in'),
                                                                   ('space',
                                                                    ('MSpace',
                                                                     'Space'),
                                                                    'in')],
                                                          'defaults': {'space': ('MSpace',
                                                                                 'Space',
                                                                                 'kObject')},
                                                          'deprecated': False,
                                                          'doc': "\r\nPositions the center-of-interest of the camera keeping the eye-point fixed in space. This method changed the orientation and translation of the camera's transform attributes as well as the center-of-interest distance.",
                                                          'inArgs': ['centerOfInterest',
                                                                     'space'],
                                                          'inverse': ('centerOfInterestPoint',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'centerOfInterest': ['const',
                                                                                                  '&'],
                                                                             'space': []},
                                                          'types': {'centerOfInterest': 'MPoint',
                                                                    'space': ('MSpace',
                                                                              'Space')}}],
                            'setClippingPlanes': [{'argInfo': {'ClippingPlanes': {'doc': '',
                                                                                  'type': 'bool'}},
                                                   'args': [('ClippingPlanes',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nTurn on/off manual setting of clip planes.',
                                                   'inArgs': ['ClippingPlanes'],
                                                   'inverse': ('isClippingPlanes',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ClippingPlanes': []},
                                                   'types': {'ClippingPlanes': 'bool'}}],
                            'setDepthOfField': [{'argInfo': {'depthOfField': {'doc': 'The depth of field value to be set',
                                                                              'type': 'bool'}},
                                                 'args': [('depthOfField',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSpecifies whether the depth of field calculation is performed for the camera. The depth of field calculation is used to give varying focus depending on the distance of the objects.',
                                                 'inArgs': ['depthOfField'],
                                                 'inverse': ('isDepthOfField',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'depthOfField': []},
                                                 'types': {'depthOfField': 'bool'}}],
                            'setDisplayFilmGate': [{'argInfo': {'displayFilmGate': {'doc': 'Specifies whether to display the film gate.',
                                                                                    'type': 'bool'}},
                                                    'args': [('displayFilmGate',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nActivate display of the film gate icons when looking through the camera.',
                                                    'inArgs': ['displayFilmGate'],
                                                    'inverse': ('isDisplayFilmGate',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'displayFilmGate': []},
                                                    'types': {'displayFilmGate': 'bool'}}],
                            'setDisplayGateMask': [{'argInfo': {'displayGateMask': {'doc': 'Specifies whether to display the film gate shaded.',
                                                                                    'type': 'bool'}},
                                                    'args': [('displayGateMask',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nActivate shaded display of the film or resolution gate mask when looking through the camera. Does not activate the film or resolution gate display.',
                                                    'inArgs': ['displayGateMask'],
                                                    'inverse': ('isDisplayGateMask',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'displayGateMask': []},
                                                    'types': {'displayGateMask': 'bool'}}],
                            'setEyePoint': [{'argInfo': {'eyeLocation': {'doc': 'The eye location to set ',
                                                                         'type': 'MPoint'},
                                                         'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('eyeLocation',
                                                       'MPoint',
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': "\r\nPositions the eye-point of the camera keeping the center of interest fixed in space. This method changed the orientation and translation of the camera's transform attributes as well as the center-of-interest distance.",
                                             'inArgs': ['eyeLocation',
                                                        'space'],
                                             'inverse': ('eyePoint',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'eyeLocation': ['const',
                                                                                '&'],
                                                                'space': []},
                                             'types': {'eyeLocation': 'MPoint',
                                                       'space': ('MSpace',
                                                                 'Space')}}],
                            'setFStop': [{'argInfo': {'fStop': {'doc': 'The F/Stop value to be set',
                                                                'type': 'double'}},
                                          'args': [('fStop',
                                                    'double',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nSets the f-stop value for the camera.',
                                          'inArgs': ['fStop'],
                                          'inverse': ('fStop', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'fStop': []},
                                          'types': {'fStop': 'double'}}],
                            'setFarClippingPlane': [{'argInfo': {'dFar': {'doc': 'The far clipping plane value to be set',
                                                                          'type': 'double',
                                                                          'unitType': u'linear'}},
                                                     'args': [('dFar',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the distances to the Far Clipping Plane.',
                                                     'inArgs': ['dFar'],
                                                     'inverse': ('farClippingPlane',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'dFar': []},
                                                     'types': {'dFar': 'double'}}],
                            'setFarFocusDistance': [{'argInfo': {'farFocusDistance': {'doc': 'The far focus distance value to be set',
                                                                                      'type': 'double',
                                                                                      'unitType': u'linear'}},
                                                     'args': [('farFocusDistance',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the farthest distance within the well-focus region',
                                                     'inArgs': ['farFocusDistance'],
                                                     'inverse': ('farFocusDistance',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'farFocusDistance': []},
                                                     'types': {'farFocusDistance': 'double'}}],
                            'setFilmFit': [{'argInfo': {'filmFit': {'doc': 'The type of film fit',
                                                                    'type': ('MFnCamera',
                                                                             'FilmFit')}},
                                            'args': [('filmFit',
                                                      ('MFnCamera',
                                                       'FilmFit'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets how the digital image is to be fitted to the film back.',
                                            'inArgs': ['filmFit'],
                                            'inverse': ('filmFit', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'filmFit': []},
                                            'types': {'filmFit': ('MFnCamera',
                                                                  'FilmFit')}}],
                            'setFilmFitOffset': [{'argInfo': {'filmFitOffset': {'doc': '',
                                                                                'type': 'double'}},
                                                  'args': [('filmFitOffset',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the film fit offset for the camera.',
                                                  'inArgs': ['filmFitOffset'],
                                                  'inverse': ('filmFitOffset',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'filmFitOffset': []},
                                                  'types': {'filmFitOffset': 'double'}}],
                            'setFilmRollOrder': [{'argInfo': {'filmRollOrder': {'doc': 'The order to apply the film roll.',
                                                                                'type': ('MFnCamera',
                                                                                         'RollOrder')}},
                                                  'args': [('filmRollOrder',
                                                            ('MFnCamera',
                                                             'RollOrder'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAssign the order in which the film back rotation is applied with respect to the pivot point.',
                                                  'inArgs': ['filmRollOrder'],
                                                  'inverse': ('filmRollOrder',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'filmRollOrder': []},
                                                  'types': {'filmRollOrder': ('MFnCamera',
                                                                              'RollOrder')}}],
                            'setFilmRollValue': [{'argInfo': {'filmRollValue': {'doc': 'Specifies the amount rotation in the film back. The film back rotation value is specified in radians.',
                                                                                'type': 'double'}},
                                                  'args': [('filmRollValue',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the film roll value for film back.',
                                                  'inArgs': ['filmRollValue'],
                                                  'inverse': ('filmRollValue',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'filmRollValue': []},
                                                  'types': {'filmRollValue': 'double'}}],
                            'setFilmTranslateH': [{'argInfo': {'translate': {'doc': 'The amount of translation normalized to the viewing area.',
                                                                             'type': 'double'}},
                                                   'args': [('translate',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the horizontal film translate.',
                                                   'inArgs': ['translate'],
                                                   'inverse': ('filmTranslateH',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'translate': []},
                                                   'types': {'translate': 'double'}}],
                            'setFilmTranslateV': [{'argInfo': {'translate': {'doc': 'The amount of translation normalized to the viewing area.',
                                                                             'type': 'double'}},
                                                   'args': [('translate',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the vertical film translate.',
                                                   'inArgs': ['translate'],
                                                   'inverse': ('filmTranslateV',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'translate': []},
                                                   'types': {'translate': 'double'}}],
                            'setFocalLength': [{'argInfo': {'focalLength': {'doc': 'The focal length value to be set',
                                                                            'type': 'double'}},
                                                'args': [('focalLength',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the focal length for the camera.',
                                                'inArgs': ['focalLength'],
                                                'inverse': ('focalLength',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'focalLength': []},
                                                'types': {'focalLength': 'double'}}],
                            'setFocusDistance': [{'argInfo': {'distance': {'doc': 'The focus distance to be set',
                                                                           'type': 'double',
                                                                           'unitType': u'linear'}},
                                                  'args': [('distance',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the focus at a certain distance in front of the camera.',
                                                  'inArgs': ['distance'],
                                                  'inverse': ('focusDistance',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'distance': []},
                                                  'types': {'distance': 'double'}}],
                            'setHorizontalFieldOfView': [{'argInfo': {'fov': {'doc': 'The horizontal field of view value to be set',
                                                                              'type': 'double',
                                                                              'unitType': u'angular'}},
                                                          'args': [('fov',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSets the horizontal field of view for the camera.',
                                                          'inArgs': ['fov'],
                                                          'inverse': ('horizontalFieldOfView',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'fov': []},
                                                          'types': {'fov': 'double'}}],
                            'setHorizontalFilmAperture': [{'argInfo': {'hFilmAperture': {'doc': 'Horizontal file aperture value to be set',
                                                                                         'type': 'double'}},
                                                           'args': [('hFilmAperture',
                                                                     'double',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nChange the horizontal size of the camera aperture. Unit used is inches.',
                                                           'inArgs': ['hFilmAperture'],
                                                           'inverse': ('horizontalFilmAperture',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'hFilmAperture': []},
                                                           'types': {'hFilmAperture': 'double'}}],
                            'setHorizontalFilmOffset': [{'argInfo': {'hOffset': {'doc': 'The horizontal film offset value to be set',
                                                                                 'type': 'double'}},
                                                         'args': [('hOffset',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nChange the horizontal offset of the film. Unit used is inches.',
                                                         'inArgs': ['hOffset'],
                                                         'inverse': ('horizontalFilmOffset',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'hOffset': []},
                                                         'types': {'hOffset': 'double'}}],
                            'setHorizontalPan': [{'argInfo': {'hPan': {'doc': 'The camera 2D horizontal pan value to be set',
                                                                       'type': 'double'}},
                                                  'args': [('hPan',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nChanges the camera 2D horizontal pan value. Unit is inches.',
                                                  'inArgs': ['hPan'],
                                                  'inverse': ('horizontalPan',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'hPan': []},
                                                  'types': {'hPan': 'double'}}],
                            'setHorizontalRollPivot': [{'argInfo': {'horizontalRollPivot': {'doc': 'Specifies the horizontal pivot value.',
                                                                                            'type': 'double',
                                                                                            'unitType': u'linear'}},
                                                        'args': [('horizontalRollPivot',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSet the horizontal roll pivot for film back roll.',
                                                        'inArgs': ['horizontalRollPivot'],
                                                        'inverse': ('horizontalRollPivot',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'horizontalRollPivot': []},
                                                        'types': {'horizontalRollPivot': 'double'}}],
                            'setHorizontalShake': [{'argInfo': {'hOffset': {'doc': 'The horizontal film-based camera shake value to be set',
                                                                            'type': 'double'}},
                                                    'args': [('hOffset',
                                                              'double',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nChange the horizontal film-based camera shake value. Unit used is inches.',
                                                    'inArgs': ['hOffset'],
                                                    'inverse': ('horizontalShake',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'hOffset': []},
                                                    'types': {'hOffset': 'double'}}],
                            'setIsOrtho': [{'argInfo': {'orthoState': {'doc': 'If true then the camera will be orthographic',
                                                                       'type': 'bool'}},
                                            'args': [('orthoState',
                                                      'bool',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSwitch the camera in and out of orthographic mode. This does not change the preset fov or the ortho width, presuming that these values are going to be set at the same time separately.',
                                            'inArgs': ['orthoState'],
                                            'inverse': ('isOrtho', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'orthoState': []},
                                            'types': {'orthoState': 'bool'}},
                                           {'argInfo': {'orthoState': {'doc': 'If true then the camera will be orthographic ',
                                                                       'type': 'bool'},
                                                        'useDist': {'doc': '',
                                                                    'type': 'double',
                                                                    'unitType': u'linear'}},
                                            'args': [('orthoState',
                                                      'bool',
                                                      'in'),
                                                     ('useDist',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSwitch the camera in and out of orthographic mode. When the switch happens, the camera has to calculate a new fov or ortho width, each of which is based on the other and a set distance. The caller can specify the distance; otherwise the center of interest is used.',
                                            'inArgs': ['orthoState',
                                                       'useDist'],
                                            'inverse': ('isOrtho', True),
                                            'outArgs': [],
                                            'pymelName': 'setOrtho',
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'orthoState': [],
                                                               'useDist': []},
                                            'types': {'orthoState': 'bool',
                                                      'useDist': 'double'}}],
                            'setLensSqueezeRatio': [{'argInfo': {'aspectRatio': {'doc': 'The lens squeeze ratio to be set',
                                                                                 'type': 'double'}},
                                                     'args': [('aspectRatio',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the squeeze ratio of the lens. The aspect ratio is expressed as width/height.',
                                                     'inArgs': ['aspectRatio'],
                                                     'inverse': ('lensSqueezeRatio',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'aspectRatio': []},
                                                     'types': {'aspectRatio': 'double'}}],
                            'setMotionBlur': [{'argInfo': {'motionBlur': {'doc': 'true turns motion blur on, false turns it off.',
                                                                          'type': 'bool'}},
                                               'args': [('motionBlur',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nTurns motion blur on/off for the camera.',
                                               'inArgs': ['motionBlur'],
                                               'inverse': ('isMotionBlur',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'motionBlur': []},
                                               'types': {'motionBlur': 'bool'}}],
                            'setNearClippingPlane': [{'argInfo': {'dNear': {'doc': 'The near clipping plane value to be set',
                                                                            'type': 'double',
                                                                            'unitType': u'linear'}},
                                                      'args': [('dNear',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the distances to the Near Clipping Plane.',
                                                      'inArgs': ['dNear'],
                                                      'inverse': ('nearClippingPlane',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'dNear': []},
                                                      'types': {'dNear': 'double'}}],
                            'setNearFarClippingPlanes': [{'argInfo': {'dFar': {'doc': 'The far clipping plane value to be set',
                                                                               'type': 'double',
                                                                               'unitType': u'linear'},
                                                                      'dNear': {'doc': 'The near clipping plane value to be set ',
                                                                                'type': 'double',
                                                                                'unitType': u'linear'}},
                                                          'args': [('dNear',
                                                                    'double',
                                                                    'in'),
                                                                   ('dFar',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSet the distances to the Near and Far Clipping Planes.',
                                                          'inArgs': ['dNear',
                                                                     'dFar'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'dFar': [],
                                                                             'dNear': []},
                                                          'types': {'dFar': 'double',
                                                                    'dNear': 'double'}}],
                            'setNearFocusDistance': [{'argInfo': {'nearFocusDistance': {'doc': 'The near focus distance value to be set',
                                                                                        'type': 'double',
                                                                                        'unitType': u'linear'}},
                                                      'args': [('nearFocusDistance',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the nearest distance within the well-focus region',
                                                      'inArgs': ['nearFocusDistance'],
                                                      'inverse': ('nearFocusDistance',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'nearFocusDistance': []},
                                                      'types': {'nearFocusDistance': 'double'}}],
                            'setOrthoWidth': [{'argInfo': {'orthoWidth': {'doc': 'The ortho width value to be set',
                                                                          'type': 'double'}},
                                               'args': [('orthoWidth',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets a new width for the ortho camera. Bad values are ignored.',
                                               'inArgs': ['orthoWidth'],
                                               'inverse': ('orthoWidth',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'orthoWidth': []},
                                               'types': {'orthoWidth': 'double'}}],
                            'setOverscan': [{'argInfo': {'overscan': {'doc': '',
                                                                      'type': 'double'}},
                                             'args': [('overscan',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the percent of overscan for this camera.',
                                             'inArgs': ['overscan'],
                                             'inverse': ('overscan',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'overscan': []},
                                             'types': {'overscan': 'double'}}],
                            'setPanZoomEnabled': [{'argInfo': {'enabled': {'doc': 'The camera 2D pan/zoom enabled toggle value to be set',
                                                                           'type': 'bool'}},
                                                   'args': [('enabled',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nChanges the toggle value for the camera 2D pan/zoom enabled attribute.',
                                                   'inArgs': ['enabled'],
                                                   'inverse': ('panZoomEnabled',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'enabled': []},
                                                   'types': {'enabled': 'bool'}}],
                            'setPostScale': [{'argInfo': {'sf': {'doc': 'The scaling factor.',
                                                                 'type': 'double'}},
                                              'args': [('sf',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the post scale value.',
                                              'inArgs': ['sf'],
                                              'inverse': ('postScale',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'sf': []},
                                              'types': {'sf': 'double'}}],
                            'setPreScale': [{'argInfo': {'sf': {'doc': 'The scaling factor.',
                                                                'type': 'double'}},
                                             'args': [('sf',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the pre scale value.',
                                             'inArgs': ['sf'],
                                             'inverse': ('preScale',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'sf': []},
                                             'types': {'sf': 'double'}}],
                            'setRenderPanZoom': [{'argInfo': {'render': {'doc': 'The camera render 2D pan/zoom toggle value to be set',
                                                                         'type': 'bool'}},
                                                  'args': [('render',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nChanges the toggle value for the camera render 2D pan/zoom enabled attribute.',
                                                  'inArgs': ['render'],
                                                  'inverse': ('renderPanZoom',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'render': []},
                                                  'types': {'render': 'bool'}}],
                            'setShakeEnabled': [{'argInfo': {'enabled': {'doc': 'The film-based camera shake toggle value to be set',
                                                                         'type': 'bool'}},
                                                 'args': [('enabled',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nChanges the toggle value for the camera shake enabled attribute. If this attribute is false, the horizontalShake and verticalShake values are ignored by the camera.',
                                                 'inArgs': ['enabled'],
                                                 'inverse': ('shakeEnabled',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'enabled': []},
                                                 'types': {'enabled': 'bool'}}],
                            'setShakeOverscan': [{'argInfo': {'overscan': {'doc': 'The camera shake overscan value to be set',
                                                                           'type': 'double'}},
                                                  'args': [('overscan',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nChanges the camera shake overscan value. Unit is a multiplier to the film aperture size. This attribute will affect the output render.',
                                                  'inArgs': ['overscan'],
                                                  'inverse': ('shakeOverscan',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'overscan': []},
                                                  'types': {'overscan': 'double'}}],
                            'setShakeOverscanEnabled': [{'argInfo': {'enabled': {'doc': 'The film-based camera shake overscan toggle value to be set',
                                                                                 'type': 'bool'}},
                                                         'args': [('enabled',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nChanges the toggle value for the camera shake overscan enabled attribute. If this attribute is false, the shakeOverscan value is ignored by the camera.',
                                                         'inArgs': ['enabled'],
                                                         'inverse': ('shakeOverscanEnabled',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'enabled': []},
                                                         'types': {'enabled': 'bool'}}],
                            'setShutterAngle': [{'argInfo': {'shutterAngle': {'doc': 'The shutter angle value to be set',
                                                                              'type': 'double',
                                                                              'unitType': u'angular'}},
                                                 'args': [('shutterAngle',
                                                           'double',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nChange the current shutter angle which is one of the variables used to compute motion blur. The shutterAngle is specified in radians.',
                                                 'inArgs': ['shutterAngle'],
                                                 'inverse': ('shutterAngle',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'shutterAngle': []},
                                                 'types': {'shutterAngle': 'double'}}],
                            'setStereoHIT': [{'argInfo': {'hit': {'doc': 'The stereo HIT value to be set',
                                                                  'type': 'double'}},
                                              'args': [('hit',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nChanges the camera stereo horizontal image translation (stereo HIT) value. Unit is inches. This has the same effect as the HFO attribute, but is intended as an input hook for use with stereo camera rigs.',
                                              'inArgs': ['hit'],
                                              'inverse': ('stereoHIT',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'hit': []},
                                              'types': {'hit': 'double'}}],
                            'setStereoHITEnabled': [{'argInfo': {'enabled': {'doc': 'The film-based camera stereo HIT toggle value to be set',
                                                                             'type': 'bool'}},
                                                     'args': [('enabled',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nChanges the toggle value for the stereo HIT enabled attribute. If this attribute is false, the stereoHIT value is ignored by the camera.',
                                                     'inArgs': ['enabled'],
                                                     'inverse': ('stereoHITEnabled',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'enabled': []},
                                                     'types': {'enabled': 'bool'}}],
                            'setTumblePivot': [{'argInfo': {'point': {'doc': 'The tumble pivot location to be set',
                                                                      'type': 'MPoint'}},
                                                'args': [('point',
                                                          'MPoint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThe tumble pivot is used for non-local tumble operations. It is in world space for "tumble pivot" mode and relative space for "local axis" mode (see setUsePivotAsLocalSpace).',
                                                'inArgs': ['point'],
                                                'inverse': ('tumblePivot',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'point': ['const',
                                                                             '&']},
                                                'types': {'point': 'MPoint'}}],
                            'setUsePivotAsLocalSpace': [{'argInfo': {'how': {'doc': 'True to use local space tumbling for this camera, or false to use the current global tumble setting in Maya (the global tumble setting can be set via the Tumble Tool Option Box). The default value is false.',
                                                                             'type': 'bool'}},
                                                         'args': [('how',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nLocal space tumbling specifies that when the camera is tumbled, the camera will rotate about its local axis, offset by the tumblePivot. The effect is like that of tilting the camera on a tripod. This per-camera setting overrides whatever tumble mode is defined globally in Maya.',
                                                         'inArgs': ['how'],
                                                         'inverse': ('usePivotAsLocalSpace',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'how': ['const']},
                                                         'types': {'how': 'bool'}}],
                            'setVerticalFieldOfView': [{'argInfo': {'fov': {'doc': 'The vertical field of view value to be set',
                                                                            'type': 'double',
                                                                            'unitType': u'angular'}},
                                                        'args': [('fov',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the vertical field of view for the camera.',
                                                        'inArgs': ['fov'],
                                                        'inverse': ('verticalFieldOfView',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'fov': []},
                                                        'types': {'fov': 'double'}}],
                            'setVerticalFilmAperture': [{'argInfo': {'vFilmAperture': {'doc': 'The vertical film aperture for the camera',
                                                                                       'type': 'double'}},
                                                         'args': [('vFilmAperture',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nChange the vertical size of the camera aperture. Unit used is inches.',
                                                         'inArgs': ['vFilmAperture'],
                                                         'inverse': ('verticalFilmAperture',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'vFilmAperture': []},
                                                         'types': {'vFilmAperture': 'double'}}],
                            'setVerticalFilmOffset': [{'argInfo': {'vOffset': {'doc': 'The vertical film offset value to be set',
                                                                               'type': 'double'}},
                                                       'args': [('vOffset',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nChange the vertical offset of the film. Unit used is inches.',
                                                       'inArgs': ['vOffset'],
                                                       'inverse': ('verticalFilmOffset',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'vOffset': []},
                                                       'types': {'vOffset': 'double'}}],
                            'setVerticalLock': [{'argInfo': {'lockFlag': {'doc': 'Vertical lock value to be set',
                                                                          'type': 'bool'}},
                                                 'args': [('lockFlag',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the vertical lock to on or off for the camera.',
                                                 'inArgs': ['lockFlag'],
                                                 'inverse': ('isVerticalLock',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'lockFlag': []},
                                                 'types': {'lockFlag': 'bool'}}],
                            'setVerticalPan': [{'argInfo': {'vPan': {'doc': 'The camera 2D vertical pan value to be set',
                                                                     'type': 'double'}},
                                                'args': [('vPan',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nChanges the camera 2D vertical pan value. Unit is inches.',
                                                'inArgs': ['vPan'],
                                                'inverse': ('verticalPan',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'vPan': []},
                                                'types': {'vPan': 'double'}}],
                            'setVerticalRollPivot': [{'argInfo': {'verticalRollPivot': {'doc': 'Specifies the vertical pivot value.',
                                                                                        'type': 'double',
                                                                                        'unitType': u'linear'}},
                                                      'args': [('verticalRollPivot',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the vertical roll pivot for film back roll.',
                                                      'inArgs': ['verticalRollPivot'],
                                                      'inverse': ('verticalRollPivot',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'verticalRollPivot': []},
                                                      'types': {'verticalRollPivot': 'double'}}],
                            'setVerticalShake': [{'argInfo': {'vOffset': {'doc': 'The vertical film-based camera shake value to be set',
                                                                          'type': 'double'}},
                                                  'args': [('vOffset',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nChanges the vertical film-based camera shake value. Unit used is inches.',
                                                  'inArgs': ['vOffset'],
                                                  'inverse': ('verticalShake',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'vOffset': []},
                                                  'types': {'vOffset': 'double'}}],
                            'setZoom': [{'argInfo': {'zoom': {'doc': 'The camera 2D zoom value to be set',
                                                              'type': 'double'}},
                                         'args': [('zoom',
                                                   'double',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nChanges the camera 2D zoom value.',
                                         'inArgs': ['zoom'],
                                         'inverse': ('zoom', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'zoom': []},
                                         'types': {'zoom': 'double'}}],
                            'shakeEnabled': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the toggle value for the camera shake enabled attribute. If this attribute is false, the horizontalShake and verticalShake values are ignored by the camera.',
                                              'inArgs': [],
                                              'inverse': ('setShakeEnabled',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The horizontal film-based camera shake toggle value for the camera',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                            'shakeOverscan': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the camera shake overscan value. Unit is a multiplier to the film aperture. This overscan is used to render a larger area than would be necessary if the camera were not shaking. This attribute will affect the output render.',
                                               'inArgs': [],
                                               'inverse': ('setShakeOverscan',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The film-based camera shake overscan value for the camera',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'shakeOverscanEnabled': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the toggle value for the camera shake overscan attribute. If this attribute is false, the shakeOverscan value is ignored by the camera.',
                                                      'inArgs': [],
                                                      'inverse': ('setShakeOverscanEnabled',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The camera shake overscan toggle value for the camera',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                            'shutterAngle': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the current shutter angle which is one of the variables used to compute motion blur. The shutter angle is specified in radians.',
                                              'inArgs': [],
                                              'inverse': ('setShutterAngle',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The shutter angle for the camera',
                                                             'qualifiers': [],
                                                             'type': 'double',
                                                             'unitType': u'angular'},
                                              'returnType': 'double',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                            'stereoHIT': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the camera stereo horizontal image translation (stereo HIT) value. Unit is inches. This has the same effect as the HFO attribute, but is intended as an input hook for use with stereo camera rigs.',
                                           'inArgs': [],
                                           'inverse': ('setStereoHIT',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The stereo HIT value for this camera',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                            'stereoHITEnabled': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the toggle value for the stereo HIT enabled attribute. If this attribute is false, the stereoHIT value is ignored by the camera.',
                                                  'inArgs': [],
                                                  'inverse': ('setStereoHITEnabled',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The camera stereo HIT toggle value for the camera',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                            'tumblePivot': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the tumble pivot value for the camera. The pivot value will be in world space coordinates unless  usePivotAsLocalSpace()  is true in which case the pivot is a relative offset.',
                                             'inArgs': [],
                                             'inverse': ('setTumblePivot',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The tumble pivot location of the camera',
                                                            'qualifiers': [],
                                                            'type': 'MPoint'},
                                             'returnType': 'MPoint',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                            'type': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nFunction set type. \r\n',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': ('MFn',
                                                              'Type')},
                                      'returnType': ('MFn', 'Type'),
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                            'unnormalizedFarClippingPlane': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns the distance to the far clipping plane.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The far clipping plane value for the camera',
                                                                             'qualifiers': [],
                                                                             'type': 'double'},
                                                              'returnType': 'double',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                            'unnormalizedNearClippingPlane': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nReturns the distance to the near clipping plane.',
                                                               'inArgs': [],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The near clipping plane value for the camera',
                                                                              'qualifiers': [],
                                                                              'type': 'double'},
                                                               'returnType': 'double',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                                               'types': {}}],
                            'upDirection': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the up direction vector for the camera.',
                                             'inArgs': ['space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The up direction vector for this camera',
                                                            'qualifiers': [],
                                                            'type': 'MVector'},
                                             'returnType': 'MVector',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'space': []},
                                             'types': {'space': ('MSpace',
                                                                 'Space')}}],
                            'usePivotAsLocalSpace': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the value of the local axis tumble setting for this camera.',
                                                      'inArgs': [],
                                                      'inverse': ('setUsePivotAsLocalSpace',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True if using local space tumbling for this camera, or false if using the current global tumble setting in Maya. See setUsePivotAsLocalSpace() for more details.',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                            'verticalFieldOfView': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the vertical field of view for the camera.',
                                                     'inArgs': [],
                                                     'inverse': ('setVerticalFieldOfView',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The vertical field of view for the camera',
                                                                    'qualifiers': [],
                                                                    'type': 'double',
                                                                    'unitType': u'angular'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                            'verticalFilmAperture': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the vertical film aperture for the camera.',
                                                      'inArgs': [],
                                                      'inverse': ('setVerticalFilmAperture',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The vertical film aperture for the camera',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                            'verticalFilmOffset': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nChange the vertical offset of the film. Unit used is inches.',
                                                    'inArgs': [],
                                                    'inverse': ('setVerticalFilmOffset',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The vertical film offset for the camera',
                                                                   'qualifiers': [],
                                                                   'type': 'double'},
                                                    'returnType': 'double',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                            'verticalPan': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the camera 2D vertical pan value. Unit is inches.',
                                             'inArgs': [],
                                             'inverse': ('setVerticalPan',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The camera 2D vertical pan value',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                            'verticalRollPivot': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\r\nReturns the vertical roll pivot's value.",
                                                   'inArgs': [],
                                                   'inverse': ('setVerticalRollPivot',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Vertical roll pivot',
                                                                  'qualifiers': [],
                                                                  'type': 'double',
                                                                  'unitType': u'linear'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                            'verticalShake': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nChange the vertical film-based camera shake value. Unit used is inches. This horizontal/vertical attribute pair acts identically to the film offset pair, but gives another point of input to that system. This allows film-based camera shake to be accessed conveniently and independently without disturbing any other film-offsetting techniques.',
                                               'inArgs': [],
                                               'inverse': ('setVerticalShake',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The vertical film-based camera shake value for the camera',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'viewDirection': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                     'type': ('MSpace',
                                                                              'Space')}},
                                               'args': [('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the view direction for the camera.',
                                               'inArgs': ['space'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The view direction vector for the camera',
                                                              'qualifiers': [],
                                                              'type': 'MVector'},
                                               'returnType': 'MVector',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'space': []},
                                               'types': {'space': ('MSpace',
                                                                   'Space')}}],
                            'zoom': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn the camera 2D zoom value, which is the percent over the film viewable frustum to display',
                                      'inArgs': [],
                                      'inverse': ('setZoom', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The camera 2D zoom value',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}]},
                'pymelEnums': {'FilmFit': "Enum('FilmFit', [('fillFilmFit', 0), ('kFillFilmFit', 0), ('horizontalFilmFit', 1), ('kHorizontalFilmFit', 1), ('verticalFilmFit', 2), ('kVerticalFilmFit', 2), ('overscanFilmFit', 3), ('kOverscanFilmFit', 3), ('invalid', 4), ('kInvalid', 4)], multiKeys=True)",
                               'RollOrder': "Enum('RollOrder', [('rotateTranslate', 0), ('kRotateTranslate', 0), ('translateRotate', 1), ('kTranslateRotate', 1)], multiKeys=True)"},
                'pymelMethods': {'aspectRatio': 'getAspectRatio',
                                 'cameraScale': 'getCameraScale',
                                 'centerOfInterest': 'getCenterOfInterest',
                                 'centerOfInterestPoint': 'getCenterOfInterestPoint',
                                 'eyePoint': 'getEyePoint',
                                 'fStop': 'getFStop',
                                 'farClippingPlane': 'getFarClippingPlane',
                                 'farFocusDistance': 'getFarFocusDistance',
                                 'filmFit': 'getFilmFit',
                                 'filmFitOffset': 'getFilmFitOffset',
                                 'filmRollOrder': 'getFilmRollOrder',
                                 'filmRollValue': 'getFilmRollValue',
                                 'filmTranslateH': 'getFilmTranslateH',
                                 'filmTranslateV': 'getFilmTranslateV',
                                 'focalLength': 'getFocalLength',
                                 'focusDistance': 'getFocusDistance',
                                 'horizontalFieldOfView': 'getHorizontalFieldOfView',
                                 'horizontalFilmAperture': 'getHorizontalFilmAperture',
                                 'horizontalFilmOffset': 'getHorizontalFilmOffset',
                                 'horizontalPan': 'getHorizontalPan',
                                 'horizontalRollPivot': 'getHorizontalRollPivot',
                                 'horizontalShake': 'getHorizontalShake',
                                 'lensSqueezeRatio': 'getLensSqueezeRatio',
                                 'nearClippingPlane': 'getNearClippingPlane',
                                 'nearFocusDistance': 'getNearFocusDistance',
                                 'orthoWidth': 'getOrthoWidth',
                                 'overscan': 'getOverscan',
                                 'panZoomEnabled': 'getPanZoomEnabled',
                                 'postScale': 'getPostScale',
                                 'preScale': 'getPreScale',
                                 'renderPanZoom': 'getRenderPanZoom',
                                 'setIsOrtho': 'setOrtho',
                                 'shakeEnabled': 'getShakeEnabled',
                                 'shakeOverscan': 'getShakeOverscan',
                                 'shakeOverscanEnabled': 'getShakeOverscanEnabled',
                                 'shutterAngle': 'getShutterAngle',
                                 'stereoHIT': 'getStereoHIT',
                                 'stereoHITEnabled': 'getStereoHITEnabled',
                                 'tumblePivot': 'getTumblePivot',
                                 'usePivotAsLocalSpace': 'getUsePivotAsLocalSpace',
                                 'verticalFieldOfView': 'getVerticalFieldOfView',
                                 'verticalFilmAperture': 'getVerticalFilmAperture',
                                 'verticalFilmOffset': 'getVerticalFilmOffset',
                                 'verticalPan': 'getVerticalPan',
                                 'verticalRollPivot': 'getVerticalRollPivot',
                                 'verticalShake': 'getVerticalShake',
                                 'zoom': 'getZoom'}},
  'MFnCameraSet': {'enums': {},
                   'invertibles': [('setLayerOrder', 'getLayerOrder'),
                                   ('setLayerSceneData',
                                    'getLayerSceneData'),
                                   ('setLayerActive', 'isLayerActive'),
                                   ('setLayerCamera', 'getLayerCamera'),
                                   ('setLayerClearDepthValue',
                                    'getLayerClearDepthValue')],
                   'methods': {'appendLayer': [{'argInfo': {'camera': {'doc': 'The camera or stereo rig for the layer ',
                                                                       'type': 'MDagPath'},
                                                            'set': {'doc': 'The set of objects used in the layer',
                                                                    'type': 'MObject'}},
                                                'args': [('camera',
                                                          'MDagPath',
                                                          'in'),
                                                         ('set',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nAppends a layer to the associated cameraSet node. The given camera and object set are used in the layer. If  MObject::kNullObj  is passed as the set, then the whole scene will be rendered in the layer.',
                                                'inArgs': ['camera',
                                                           'set'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'camera': ['const',
                                                                              '&'],
                                                                   'set': ['const',
                                                                           '&']},
                                                'types': {'camera': 'MDagPath',
                                                          'set': 'MObject'}},
                                               {'argInfo': {'camera': {'doc': 'The camera or stereo rig for the layer',
                                                                       'type': 'MDagPath'}},
                                                'args': [('camera',
                                                          'MDagPath',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nAppends a layer to the associated cameraSet node using the given camera. The whole scene will be used with this layer as no object set is provided.',
                                                'inArgs': ['camera'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'camera': ['const',
                                                                              '&']},
                                                'types': {'camera': 'MDagPath'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nClass name. \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nClear all of the camera layers.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'create': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nCreates a new cameraSet dependency node and puts it in the dependency graph.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A pointer to the new cameraSet node object.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'returnStatus': ['*']},
                                           'types': {}},
                                          {'argInfo': {'camList': {'doc': 'The list of cameras or stereo rigs ',
                                                                   'type': 'MDagPathArray'}},
                                           'args': [('camList',
                                                     'MDagPathArray',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nCreates a new cameraSet dependency node and puts it in the dependency graph. The method takes a list of cameras and creates a camera layer for each corresponding camera. Sets are not connected.',
                                           'inArgs': ['camList'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A pointer to the new cameraSet node object.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'camList': ['const',
                                                                          '&'],
                                                              'returnStatus': ['*']},
                                           'types': {'camList': 'MDagPathArray'}},
                                          {'argInfo': {'name': {'doc': 'The name for the new cameraSet node ',
                                                                'type': 'MString'}},
                                           'args': [('name',
                                                     'MString',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nCreates a new cameraSet dependency node and puts it in the dependency graph.',
                                           'inArgs': ['name'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A pointer to the new cameraSet node object.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'name': ['const',
                                                                       '&'],
                                                              'returnStatus': ['*']},
                                           'types': {'name': 'MString'}},
                                          {'argInfo': {'camList': {'doc': 'The list of cameras or stereo rigs ',
                                                                   'type': 'MDagPathArray'},
                                                       'setList': {'doc': 'The list of sets ',
                                                                   'type': 'MObjectArray'}},
                                           'args': [('camList',
                                                     'MDagPathArray',
                                                     'in'),
                                                    ('setList',
                                                     'MObjectArray',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nCreates a new cameraSet dependency node and puts it in the dependency graph. The method takes a list of cameras and object sets and creates a camera layer for each corresponding camera and object set.',
                                           'inArgs': ['camList',
                                                      'setList'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A pointer to the new cameraSet node object.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'camList': ['const',
                                                                          '&'],
                                                              'returnStatus': ['*'],
                                                              'setList': ['const',
                                                                          '&']},
                                           'types': {'camList': 'MDagPathArray',
                                                     'setList': 'MObjectArray'}},
                                          {'argInfo': {'camList': {'doc': 'The list of cameras or stereo rigs ',
                                                                   'type': 'MDagPathArray'},
                                                       'name': {'doc': 'The name for the new cameraSet node ',
                                                                'type': 'MString'},
                                                       'setList': {'doc': 'The list of sets ',
                                                                   'type': 'MObjectArray'}},
                                           'args': [('name',
                                                     'MString',
                                                     'in'),
                                                    ('camList',
                                                     'MDagPathArray',
                                                     'in'),
                                                    ('setList',
                                                     'MObjectArray',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nCreates a new cameraSet dependency node and puts it in the dependency graph. The method takes a list of cameras and object sets and creates a camera layer for each corresponding camera and object set.',
                                           'inArgs': ['name',
                                                      'camList',
                                                      'setList'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A pointer to the new cameraSet node object.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'camList': ['const',
                                                                          '&'],
                                                              'name': ['const',
                                                                       '&'],
                                                              'returnStatus': ['*'],
                                                              'setList': ['const',
                                                                          '&']},
                                           'types': {'camList': 'MDagPathArray',
                                                     'name': 'MString',
                                                     'setList': 'MObjectArray'}}],
                               'deleteLayer': [{'argInfo': {'index': {'doc': 'The index of the layer',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nDeletes the layer denoted by the given index.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'getLayerCamera': [{'argInfo': {'camera': {'doc': 'The camera for the layer',
                                                                          'type': 'MDagPath'},
                                                               'index': {'doc': 'The index of the layer ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in'),
                                                            ('camera',
                                                             'MDagPath',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nGet the camera used for a particular layer.',
                                                   'inArgs': ['index'],
                                                   'inverse': ('setLayerCamera',
                                                               False),
                                                   'outArgs': ['camera'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'camera': ['&'],
                                                                      'index': ['unsigned']},
                                                   'types': {'camera': 'MDagPath',
                                                             'index': 'uint'}}],
                               'getLayerClearDepthValue': [{'argInfo': {'depth': {'doc': 'The clear depth value',
                                                                                  'type': 'bool'},
                                                                        'index': {'doc': 'The index of the layer ',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in'),
                                                                     ('depth',
                                                                      'bool',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nThis method gets the clearDepth attribute value for the specified camera layer',
                                                            'inArgs': ['index'],
                                                            'inverse': ('setLayerClearDepthValue',
                                                                        False),
                                                            'outArgs': ['depth'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'depth': ['&'],
                                                                               'index': ['unsigned']},
                                                            'types': {'depth': 'bool',
                                                                      'index': 'uint'}}],
                               'getLayerOrder': [{'argInfo': {'index': {'doc': 'The index of the layer ',
                                                                        'type': 'uint'},
                                                              'order': {'doc': 'The processing order',
                                                                        'type': 'int'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in'),
                                                           ('order',
                                                            'int',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nGet the processing order of a particular layer.',
                                                  'inArgs': ['index'],
                                                  'inverse': ('setLayerOrder',
                                                              False),
                                                  'outArgs': ['order'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned'],
                                                                     'order': ['&']},
                                                  'types': {'index': 'uint',
                                                            'order': 'int'}}],
                               'getLayerSceneData': [{'argInfo': {'index': {'doc': 'The index of the layer ',
                                                                            'type': 'uint'},
                                                                  'set': {'doc': 'The object set for the layer',
                                                                          'type': 'MObject'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in'),
                                                               ('set',
                                                                'MObject',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the scene data used for a particular layer. The returned scene data could be  MObject::kNullObj  if no scene data has been set. The operation will still be deemed successful.',
                                                      'inArgs': ['index'],
                                                      'inverse': ('setLayerSceneData',
                                                                  False),
                                                      'outArgs': ['set'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned'],
                                                                         'set': ['&']},
                                                      'types': {'index': 'uint',
                                                                'set': 'MObject'}}],
                               'getNumLayers': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturn the number of layers in the cameraSet.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of layers',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'returnStatus': ['*']},
                                                 'types': {}}],
                               'getSortedIndices': [{'argInfo': {'sortedIndices': {'doc': 'The sorted indices',
                                                                                   'type': 'MUintArray'}},
                                                     'args': [('sortedIndices',
                                                               'MUintArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nGet a list of the layer indices, sorted by the order attribute.',
                                                     'inArgs': [],
                                                     'outArgs': ['sortedIndices'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'sortedIndices': ['&']},
                                                     'types': {'sortedIndices': 'MUintArray'}}],
                               'insertLayer': [{'argInfo': {'camera': {'doc': 'The camera for the layer ',
                                                                       'type': 'MDagPath'},
                                                            'index': {'doc': 'The index of the layer ',
                                                                      'type': 'uint'},
                                                            'set': {'doc': 'The set of objects used in the layer',
                                                                    'type': 'MObject'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in'),
                                                         ('camera',
                                                          'MDagPath',
                                                          'in'),
                                                         ('set',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nInserts a layer at the given index to the associated cameraSet node using the given camera. The index value must be in the range from 0 to the number of layers currently defined. The given camera and object set are used in the layer. If  MObject::kNullObj  is passed as the set, then the whole scene will be rendered in the layer.',
                                                'inArgs': ['index',
                                                           'camera',
                                                           'set'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'camera': ['const',
                                                                              '&'],
                                                                   'index': ['unsigned'],
                                                                   'set': ['const',
                                                                           '&']},
                                                'types': {'camera': 'MDagPath',
                                                          'index': 'uint',
                                                          'set': 'MObject'}},
                                               {'argInfo': {'camera': {'doc': 'The camera for the layer',
                                                                       'type': 'MDagPath'},
                                                            'index': {'doc': 'The index of the layer ',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in'),
                                                         ('camera',
                                                          'MDagPath',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nInserts a layer at the given index to the associated cameraSet node using the given camera. The index value must be in the range from 0 to the number of layers currently defined. The whole scene will be used with this layer as no object set is provided.',
                                                'inArgs': ['index',
                                                           'camera'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'camera': ['const',
                                                                              '&'],
                                                                   'index': ['unsigned']},
                                                'types': {'camera': 'MDagPath',
                                                          'index': 'uint'}}],
                               'isLayerActive': [{'argInfo': {'index': {'doc': 'The index of the layer ',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nGet whether a particular layer is active.',
                                                  'inArgs': ['index'],
                                                  'inverse': ('setLayerActive',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Whether the layer is being processed',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned'],
                                                                     'returnStatus': ['*']},
                                                  'types': {'index': 'uint'}}],
                               'setLayerActive': [{'argInfo': {'index': {'doc': 'The index of the layer ',
                                                                         'type': 'uint'},
                                                               'isActive': {'doc': 'Whether the layer should be processed',
                                                                            'type': 'bool'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in'),
                                                            ('isActive',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSet a particular layer to be active.',
                                                   'inArgs': ['index',
                                                              'isActive'],
                                                   'inverse': ('isLayerActive',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'index': ['unsigned'],
                                                                      'isActive': []},
                                                   'types': {'index': 'uint',
                                                             'isActive': 'bool'}}],
                               'setLayerCamera': [{'argInfo': {'camera': {'doc': 'The camera for the layer',
                                                                          'type': 'MDagPath'},
                                                               'index': {'doc': 'The index of the layer ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in'),
                                                            ('camera',
                                                             'MDagPath',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSet the camera to be used for a particular layer.',
                                                   'inArgs': ['index',
                                                              'camera'],
                                                   'inverse': ('getLayerCamera',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'camera': ['const',
                                                                                 '&'],
                                                                      'index': ['unsigned']},
                                                   'types': {'camera': 'MDagPath',
                                                             'index': 'uint'}}],
                               'setLayerClearDepthValue': [{'argInfo': {'depth': {'doc': 'The clear depth value',
                                                                                  'type': 'bool'},
                                                                        'index': {'doc': 'The index of the layer ',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in'),
                                                                     ('depth',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nThis method sets the clearDepth attribute for the specified camera layer.',
                                                            'inArgs': ['index',
                                                                       'depth'],
                                                            'inverse': ('getLayerClearDepthValue',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'depth': [],
                                                                               'index': ['unsigned']},
                                                            'types': {'depth': 'bool',
                                                                      'index': 'uint'}}],
                               'setLayerOrder': [{'argInfo': {'index': {'doc': 'The index of the layer ',
                                                                        'type': 'uint'},
                                                              'order': {'doc': 'The order number',
                                                                        'type': 'int'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in'),
                                                           ('order',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nSet the processing order of a particular layer.',
                                                  'inArgs': ['index',
                                                             'order'],
                                                  'inverse': ('getLayerOrder',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned'],
                                                                     'order': []},
                                                  'types': {'index': 'uint',
                                                            'order': 'int'}}],
                               'setLayerSceneData': [{'argInfo': {'index': {'doc': 'The index of the layer ',
                                                                            'type': 'uint'},
                                                                  'set': {'doc': 'The object set for the layer',
                                                                          'type': 'MObject'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in'),
                                                               ('set',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet the scene data to be used for a particular layer.',
                                                      'inArgs': ['index',
                                                                 'set'],
                                                      'inverse': ('getLayerSceneData',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned'],
                                                                         'set': ['const',
                                                                                 '&']},
                                                      'types': {'index': 'uint',
                                                                'set': 'MObject'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nFunction set type. \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {}},
  'MFnCharacter': {'enums': {},
                   'methods': {'addCurveToClip': [{'argInfo': {'curve': {'doc': 'the animation curve to be added to the clip ',
                                                                         'type': 'MObject'},
                                                               'dgMod': {'doc': 'command modifier used for undo and redo',
                                                                         'type': 'MDGModifier'},
                                                               'plug': {'doc': 'plug that this animCurve will drive ',
                                                                        'type': 'MPlug'},
                                                               'sourceClip': {'doc': 'a source clip specifying the start and duratiohn of the clip ',
                                                                              'type': 'MObject'}},
                                                   'args': [('curve',
                                                             'MObject',
                                                             'in'),
                                                            ('sourceClip',
                                                             'MObject',
                                                             'in'),
                                                            ('plug',
                                                             'MPlug',
                                                             'in'),
                                                            ('dgMod',
                                                             'MDGModifier',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nAdds an animation curve to a clip. The user must provide the animation curve, and the related source clip node (typically created using MFnCharacter::createSourceClip). The user must also specify the plug that the clip will drive. The plug must be a member of the character managed by this  MFnCharacter .',
                                                   'inArgs': ['curve',
                                                              'sourceClip',
                                                              'plug',
                                                              'dgMod'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'curve': ['&'],
                                                                      'dgMod': ['&'],
                                                                      'plug': ['&'],
                                                                      'sourceClip': ['&']},
                                                   'types': {'curve': 'MObject',
                                                             'dgMod': 'MDGModifier',
                                                             'plug': 'MPlug',
                                                             'sourceClip': 'MObject'}}],
                               'attachInstanceToCharacter': [{'argInfo': {'dgMod': {'doc': 'command modifier used for undo and redo',
                                                                                    'type': 'MDGModifier'},
                                                                          'instanceClip': {'doc': 'the animClip node representing the clipInstance ',
                                                                                           'type': 'MObject'}},
                                                              'args': [('instanceClip',
                                                                        'MObject',
                                                                        'in'),
                                                                       ('dgMod',
                                                                        'MDGModifier',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nAttaches an instance of a clip to the character. If the source clip related to the clip instance is not already attached to the character, it will be attached as well.',
                                                              'inArgs': ['instanceClip',
                                                                         'dgMod'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'dgMod': ['&'],
                                                                                 'instanceClip': ['&']},
                                                              'types': {'dgMod': 'MDGModifier',
                                                                        'instanceClip': 'MObject'}}],
                               'attachSourceToCharacter': [{'argInfo': {'dgMod': {'doc': 'command modifier used for undo and redo',
                                                                                  'type': 'MDGModifier'},
                                                                        'sourceClip': {'doc': 'source clip to be attached ',
                                                                                       'type': 'MObject'}},
                                                            'args': [('sourceClip',
                                                                      'MObject',
                                                                      'in'),
                                                                     ('dgMod',
                                                                      'MDGModifier',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': "\r\nAttaches a given source clip node (created using  MFnClip::createSourceClip ) to the character's clipLibrary. Attaches a clipLibrary and clipScheduler to the character if they are not attached already.",
                                                            'inArgs': ['sourceClip',
                                                                       'dgMod'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'dgMod': ['&'],
                                                                               'sourceClip': ['&']},
                                                            'types': {'dgMod': 'MDGModifier',
                                                                      'sourceClip': 'MObject'}}],
                               'blendExists': [{'argInfo': {'blendResult': {'doc': 'the blend, if a blend is found',
                                                                            'type': 'MObject'},
                                                            'instancedClip1': {'doc': 'clip ',
                                                                               'type': 'MObject'},
                                                            'instancedClip2': {'doc': 'another clip ',
                                                                               'type': 'MObject'}},
                                                'args': [('instancedClip1',
                                                          'MObject',
                                                          'in'),
                                                         ('instancedClip2',
                                                          'MObject',
                                                          'in'),
                                                         ('blendResult',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn true if a blend exists between the two instanced clips on the character. If a blend exists, the animBlend node related to the blend is also returned.',
                                                'inArgs': ['instancedClip1',
                                                           'instancedClip2',
                                                           'blendResult'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true, if a blend was found between the two clips',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'blendResult': ['&'],
                                                                   'instancedClip1': ['&'],
                                                                   'instancedClip2': ['&']},
                                                'types': {'blendResult': 'MObject',
                                                          'instancedClip1': 'MObject',
                                                          'instancedClip2': 'MObject'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClass name. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'createBlend': [{'argInfo': {'blendAnimCurve': {'doc': 'animCurve defining the type of the blend ',
                                                                               'type': 'MObject'},
                                                            'dgMod': {'doc': 'command modifier used for undo and redo ',
                                                                      'type': 'MDGModifier'},
                                                            'instancedClip1': {'doc': 'clip to be blended ',
                                                                               'type': 'MObject'},
                                                            'instancedClip2': {'doc': 'another clip to be blended ',
                                                                               'type': 'MObject'}},
                                                'args': [('instancedClip1',
                                                          'MObject',
                                                          'in'),
                                                         ('instancedClip2',
                                                          'MObject',
                                                          'in'),
                                                         ('blendAnimCurve',
                                                          'MObject',
                                                          'in'),
                                                         ('dgMod',
                                                          'MDGModifier',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nCreates a blend between two instanced clips on the character. The blend is defined by a specified paramCurve, which should be keyed between times of 0 and 1. Time 0 corresponds to the start time of the blend. Time 1 corresponds to the end time of the blend. The blend will be performed on the clips according to the keyed value of the blend curve, using the equation: (value)*clip1 + (1-value)*clip2. For example, let's say the blend curve goes from a value of (0,0) to (1,1). At the start of the blend you will have 100% of clip1, and 0% of clip2. At the end of the blend you will have 0% of clip1, and 100% of clip2.",
                                                'inArgs': ['instancedClip1',
                                                           'instancedClip2',
                                                           'blendAnimCurve',
                                                           'dgMod'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The resulting animBlend node',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'blendAnimCurve': ['&'],
                                                                   'dgMod': ['&'],
                                                                   'instancedClip1': ['&'],
                                                                   'instancedClip2': ['&']},
                                                'types': {'blendAnimCurve': 'MObject',
                                                          'dgMod': 'MDGModifier',
                                                          'instancedClip1': 'MObject',
                                                          'instancedClip2': 'MObject'}}],
                               'getBlend': [{'argInfo': {'index': {'doc': 'Index of the desired node. ',
                                                                   'type': 'int'}},
                                             'args': [('index',
                                                       'int',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the animBlendInOut node corresponding to the specified index.',
                                             'inArgs': ['index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MObject containing an animBlendInOut node',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'index': []},
                                             'types': {'index': 'int'}}],
                               'getBlendClips': [{'argInfo': {'clip1': {'doc': 'the first of the clips being blended ',
                                                                        'type': 'MObject'},
                                                              'clip2': {'doc': 'the second of the clips being blended',
                                                                        'type': 'MObject'},
                                                              'index': {'doc': 'the index of the blend ',
                                                                        'type': 'int'}},
                                                  'args': [('index',
                                                            'int',
                                                            'in'),
                                                           ('clip1',
                                                            'MObject',
                                                            'out'),
                                                           ('clip2',
                                                            'MObject',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the clip nodes that are blended by the blend node corresponding to the specified index.',
                                                  'inArgs': ['index'],
                                                  'outArgs': ['clip1',
                                                              'clip2'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'clip1': ['&'],
                                                                     'clip2': ['&'],
                                                                     'index': []},
                                                  'types': {'clip1': 'MObject',
                                                            'clip2': 'MObject',
                                                            'index': 'int'}}],
                               'getBlendCount': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the number of blends that have been added to clips on this character.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Number of blends on clips in this character',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                               'getCharacterThatOwnsPlug': [{'argInfo': {'plug': {'doc': 'MPlug containing a plug for which you want to find the related character ',
                                                                                  'type': 'MPlug'},
                                                                         'result': {'doc': 'Mobject containing a character if the plug is in a character, else an empty MObject',
                                                                                    'type': 'MObject'}},
                                                             'args': [('plug',
                                                                       'MPlug',
                                                                       'in'),
                                                                      ('result',
                                                                       'MObject',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nGiven a plug, test the plug to see if it is owned by a character. If a character controls this plug, the character will be returned',
                                                             'inArgs': ['plug',
                                                                        'result'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'true, if the plug is in a character ',
                                                                            'qualifiers': [],
                                                                            'type': 'bool'},
                                                             'returnType': 'bool',
                                                             'static': False,
                                                             'typeQualifiers': {'plug': ['&'],
                                                                                'result': ['&']},
                                                             'types': {'plug': 'MPlug',
                                                                       'result': 'MObject'}}],
                               'getClipScheduler': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the clipScheduler node that manages the playback of clips on this character. If no clips have been created for this character, this method will return an empty  MObject .',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'MObject containing a clipScheduler node',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                               'getMemberPlugs': [{'argInfo': {'result': {'doc': 'storage for the returned list of members',
                                                                          'type': 'MPlugArray'}},
                                                   'args': [('result',
                                                             'MPlugArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the members of the character set that are attributes. Return them as a plug array. A character set can contain only attributes and subcharacters. To get all of the members of the character, use  MFnSet::getMembers . To get the subcharacters, use MFnCharacter::getSubcharacters.',
                                                   'inArgs': [],
                                                   'outArgs': ['result'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'result': ['&']},
                                                   'types': {'result': 'MPlugArray'}}],
                               'getScheduledClip': [{'argInfo': {'index': {'doc': 'Clip index. ',
                                                                           'type': 'int'}},
                                                     'args': [('index',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn the scheduled animClip node corresponding to the specified index. The specified index should range from 0 to clipCount-1 where clipCount is the value returned by  MFnCharacter::getScheduledClipCount .',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'MObject containing an animClip node',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'index': []},
                                                     'types': {'index': 'int'}}],
                               'getScheduledClipCount': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturn the number of clips that have been scheduled on this character.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Number of clips scheduled on this character',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                               'getSourceClip': [{'argInfo': {'index': {'doc': 'Clip index. ',
                                                                        'type': 'int'}},
                                                  'args': [('index',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the animClip node corresponding to the specified index. The animClip node will be a source clip node. The specified index should range from 0 to clipCount-1 where clipCount is the value returned by  MFnCharacter::getSourceClipCount .',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'MObject containing an animClip node',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'index': []},
                                                  'types': {'index': 'int'}}],
                               'getSourceClipCount': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn the number of source clips managed by the clipLibrary node of this character. For more information on source clips, refer to the description of the  MFnCharacter  node.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Number of source clips owned by the library on this character',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                               'getSubCharacters': [{'argInfo': {'result': {'doc': 'storage for the returned list of members',
                                                                            'type': 'MSelectionList'}},
                                                     'args': [('result',
                                                               'MSelectionList',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet a list of the subcharacters that are members of the character set.',
                                                     'inArgs': [],
                                                     'outArgs': ['result'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'result': ['&']},
                                                     'types': {'result': 'MSelectionList'}}],
                               'removeBlend': [{'argInfo': {'dgMod': {'doc': 'command modifier used for undo and redo ',
                                                                      'type': 'MDGModifier'},
                                                            'instancedClip1': {'doc': 'clip ',
                                                                               'type': 'MObject'},
                                                            'instancedClip2': {'doc': 'another clip ',
                                                                               'type': 'MObject'}},
                                                'args': [('instancedClip1',
                                                          'MObject',
                                                          'in'),
                                                         ('instancedClip2',
                                                          'MObject',
                                                          'in'),
                                                         ('dgMod',
                                                          'MDGModifier',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRemove the blend between the two instanced clips on the character. If a blend exists and was deleted, returns true. If a blend did not exist, returns false.',
                                                'inArgs': ['instancedClip1',
                                                           'instancedClip2',
                                                           'dgMod'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true, if a blend was found and deleted ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'dgMod': ['&'],
                                                                   'instancedClip1': ['&'],
                                                                   'instancedClip2': ['&']},
                                                'types': {'dgMod': 'MDGModifier',
                                                          'instancedClip1': 'MObject',
                                                          'instancedClip2': 'MObject'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {}},
  'MFnCircleSweepManip': {'enums': {},
                          'invertibles': [('setEndPoint', 'endPoint'),
                                          ('setStartPoint', 'startPoint')],
                          'methods': {'angleIndex': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the index for the angle of CircleSweepManip. The data type corresponding to this index is a double.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The angle index',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                      'axisIndex': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the index for the axis of CircleSweepManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The axis index',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                      'centerIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the index for the center of the CircleSweepManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The center index',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nClass name. \r\n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'connectToAnglePlug': [{'argInfo': {'anglePlug': {'doc': 'the angle plug',
                                                                                        'type': 'MPlug'}},
                                                              'args': [('anglePlug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nConnect to the angle plug. The data type corresponding to the anglePlug is a double. (Note that  MFnUnitAttribute::kAngle  is used to specify an angle attribute.)',
                                                              'inArgs': ['anglePlug'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'anglePlug': ['&']},
                                                              'types': {'anglePlug': 'MPlug'}}],
                                      'create': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nCreates a new CircleSweepManip. This function set's object is set to be the new manipulator.",
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Newly created CircleSweepManip',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}},
                                                 {'argInfo': {'angleName': {'doc': 'Label for the angle value which appears in the feedback line. ',
                                                                            'type': 'MString'},
                                                              'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                            'type': 'MString'}},
                                                  'args': [('manipName',
                                                            'MString',
                                                            'in'),
                                                           ('angleName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nCreates a new CircleSweepManip. This function set's object is set to be the new manipulator.",
                                                  'inArgs': ['manipName',
                                                             'angleName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Newly created CircleSweepManip.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'angleName': ['const',
                                                                                   '&'],
                                                                     'manipName': ['const',
                                                                                   '&']},
                                                  'types': {'angleName': 'MString',
                                                            'manipName': 'MString'}}],
                                      'endCircleIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns the index for the end of the circle of CircleSweepManip. The data type corresponding to this index is a double.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The circle end index',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                      'endPoint': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the end point.',
                                                    'inArgs': [],
                                                    'inverse': ('setEndPoint',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The end point',
                                                                   'qualifiers': [],
                                                                   'type': 'MPoint'},
                                                    'returnType': 'MPoint',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                      'setAngle': [{'argInfo': {'angle': {'doc': 'the angle of the CircleSweepManip',
                                                                          'type': 'MAngle'}},
                                                    'args': [('angle',
                                                              'MAngle',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the angle of the CircleSweepManip.',
                                                    'inArgs': ['angle'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'angle': []},
                                                    'types': {'angle': 'MAngle'}}],
                                      'setCenterPoint': [{'argInfo': {'centerPoint': {'doc': 'the center point of the CircleSweepManip',
                                                                                      'type': 'MPoint'}},
                                                          'args': [('centerPoint',
                                                                    'MPoint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSets the center point of the CircleSweepManip.',
                                                          'inArgs': ['centerPoint'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'centerPoint': ['const',
                                                                                             '&']},
                                                          'types': {'centerPoint': 'MPoint'}}],
                                      'setDrawAsArc': [{'argInfo': {'state': {'doc': 'whether or not to draw as arc',
                                                                              'type': 'bool'}},
                                                        'args': [('state',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets whether or not to draw as arc.',
                                                        'inArgs': ['state'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'state': []},
                                                        'types': {'state': 'bool'}}],
                                      'setEndPoint': [{'argInfo': {'endPoint': {'doc': 'the end point of the CircleSweepManip',
                                                                                'type': 'MPoint'}},
                                                       'args': [('endPoint',
                                                                 'MPoint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the end point of the CircleSweepManip.',
                                                       'inArgs': ['endPoint'],
                                                       'inverse': ('endPoint',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'endPoint': ['const',
                                                                                       '&']},
                                                       'types': {'endPoint': 'MPoint'}}],
                                      'setNormal': [{'argInfo': {'normal': {'doc': 'the normal of the CircleSweepManip',
                                                                            'type': 'MVector'}},
                                                     'args': [('normal',
                                                               'MVector',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the normal of the CircleSweepManip.',
                                                     'inArgs': ['normal'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'normal': ['const',
                                                                                   '&']},
                                                     'types': {'normal': 'MVector'}}],
                                      'setRadius': [{'argInfo': {'radius': {'doc': 'the radius of the CircleSweepManip',
                                                                            'type': 'double'}},
                                                     'args': [('radius',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the radius of the CircleSweepManip.',
                                                     'inArgs': ['radius'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'radius': []},
                                                     'types': {'radius': 'double'}}],
                                      'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the CircleSweepManip',
                                                                                    'type': 'MPoint'}},
                                                         'args': [('startPoint',
                                                                   'MPoint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the start point of the CircleSweepManip.',
                                                         'inArgs': ['startPoint'],
                                                         'inverse': ('startPoint',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'startPoint': ['const',
                                                                                           '&']},
                                                         'types': {'startPoint': 'MPoint'}}],
                                      'startCircleIndex': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns the index for the start of the circle of CircleSweepManip. The data type corresponding to this index is a double.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The circle start index',
                                                                           'qualifiers': [],
                                                                           'type': 'int'},
                                                            'returnType': 'int',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                      'startPoint': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the start point.',
                                                      'inArgs': [],
                                                      'inverse': ('setStartPoint',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The start point',
                                                                     'qualifiers': [],
                                                                     'type': 'MPoint'},
                                                      'returnType': 'MPoint',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nFunction set type. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'endPoint': 'getEndPoint',
                                           'startPoint': 'getStartPoint'}},
  'MFnClip': {'enums': {},
              'invertibles': [('setPreCycle', 'getPreCycle'),
                              ('setScale', 'getScale'),
                              ('setPostCycle', 'getPostCycle'),
                              ('setCycle', 'getCycle'),
                              ('setAbsoluteChannelSettings',
                               'getAbsoluteChannelSettings'),
                              ('setEnabled', 'getEnabled'),
                              ('setTrack', 'getTrack'),
                              ('setWeight', 'getWeight'),
                              ('setAbsolute', 'getAbsolute'),
                              ('setStartFrame', 'getStartFrame')],
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nClass name. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'createInstancedClip': [{'argInfo': {'absolute': {'doc': 'whether the clip is absolute (1) or relative (0) ',
                                                                            'type': 'bool'},
                                                               'dgMod': {'doc': 'command modifier used for undo and redo ',
                                                                         'type': 'MDGModifier'},
                                                               'postCycle': {'doc': 'post cycle for the clip ',
                                                                             'type': 'double'},
                                                               'preCycle': {'doc': 'pre cycle for the clip ',
                                                                            'type': 'double'},
                                                               'scale': {'doc': 'scale for the clip',
                                                                         'type': 'double'},
                                                               'sourceClip': {'doc': 'the source clip node ',
                                                                              'type': 'MObject'},
                                                               'start': {'doc': 'start frame where the instance will be scheduled ',
                                                                         'type': 'MTime'},
                                                               'weight': {'doc': 'weight for the clip ',
                                                                          'type': 'double'}},
                                                   'args': [('sourceClip',
                                                             'MObject',
                                                             'in'),
                                                            ('start',
                                                             'MTime',
                                                             'in'),
                                                            ('dgMod',
                                                             'MDGModifier',
                                                             'in'),
                                                            ('absolute',
                                                             'bool',
                                                             'in'),
                                                            ('postCycle',
                                                             'double',
                                                             'in'),
                                                            ('weight',
                                                             'double',
                                                             'in'),
                                                            ('scale',
                                                             'double',
                                                             'in'),
                                                            ('preCycle',
                                                             'double',
                                                             'in')],
                                                   'defaults': {'absolute': '1',
                                                                'postCycle': 0.0,
                                                                'preCycle': 0.0,
                                                                'scale': 1.0,
                                                                'weight': 1.0},
                                                   'deprecated': False,
                                                   'doc': '\r\nCreates an instance of a clip that will be viewable in the Trax editor.',
                                                   'inArgs': ['sourceClip',
                                                              'start',
                                                              'dgMod',
                                                              'absolute',
                                                              'postCycle',
                                                              'weight',
                                                              'scale',
                                                              'preCycle'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The newly created clip.',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'absolute': [],
                                                                      'dgMod': ['&'],
                                                                      'postCycle': [],
                                                                      'preCycle': [],
                                                                      'scale': [],
                                                                      'sourceClip': ['&'],
                                                                      'start': ['const',
                                                                                '&'],
                                                                      'weight': []},
                                                   'types': {'absolute': 'bool',
                                                             'dgMod': 'MDGModifier',
                                                             'postCycle': 'double',
                                                             'preCycle': 'double',
                                                             'scale': 'double',
                                                             'sourceClip': 'MObject',
                                                             'start': 'MTime',
                                                             'weight': 'double'}}],
                          'createSourceClip': [{'argInfo': {'dgMod': {'doc': 'command modifier used for undo and redo ',
                                                                      'type': 'MDGModifier'},
                                                            'sourceDuration': {'doc': 'time extent of the clip ',
                                                                               'type': 'MTime'},
                                                            'sourceStart': {'doc': 'time on clip animCurves that represents clip start ',
                                                                            'type': 'MTime'}},
                                                'args': [('sourceStart',
                                                          'MTime',
                                                          'in'),
                                                         ('sourceDuration',
                                                          'MTime',
                                                          'in'),
                                                         ('dgMod',
                                                          'MDGModifier',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nCreates a source clip node and associates it with this function set. Each animation clip has a single source clip, which defines the startFrame and duration of the clip's animation curves. The startFrame and duration act as a window onto the animation curves, defining the range of animation that is considered part of the clip. After a source clip node is created, it can be passed to a  MFnCharacter  along with the clip animCurves in order to associate the clip with the character.",
                                                'inArgs': ['sourceStart',
                                                           'sourceDuration',
                                                           'dgMod'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The newly created clip.',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'dgMod': ['&'],
                                                                   'sourceDuration': ['const',
                                                                                      '&'],
                                                                   'sourceStart': ['const',
                                                                                   '&']},
                                                'types': {'dgMod': 'MDGModifier',
                                                          'sourceDuration': 'MTime',
                                                          'sourceStart': 'MTime'}}],
                          'getAbsolute': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': '\n This method is obsolete. \n',
                                           'inArgs': [],
                                           'inverse': ('setAbsolute',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': "The value of this clip's offset attribute.",
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                          'getAbsoluteChannelSettings': [{'argInfo': {'absoluteChannels': {'doc': 'array to store the result',
                                                                                           'type': 'MIntArray'}},
                                                          'args': [('absoluteChannels',
                                                                    'MIntArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturn an array indicating which channels of the clip are absolute and which are relative. The length of the array is equal to the members in the character. A value of one in the array indicates absolute and a value of 0 indicates relative.',
                                                          'inArgs': [],
                                                          'inverse': ('setAbsoluteChannelSettings',
                                                                      False),
                                                          'outArgs': ['absoluteChannels'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'absoluteChannels': ['&']},
                                                          'types': {'absoluteChannels': 'MIntArray'}}],
                          'getCycle': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': [],
                                        'inverse': ('setCycle', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': "The value of this clip's cycle attribute.",
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                          'getEnabled': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nReturn the value of this clip's enable attribute",
                                          'inArgs': [],
                                          'inverse': ('setEnabled',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': "The value of this clip's enable attribute.",
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                          'getMemberAnimCurves': [{'argInfo': {'associatedAttrs': {'doc': 'array to store the character members',
                                                                                   'type': 'MPlugArray'},
                                                               'curves': {'doc': 'array to store the result curves ',
                                                                          'type': 'MObjectArray'}},
                                                   'args': [('curves',
                                                             'MObjectArray',
                                                             'out'),
                                                            ('associatedAttrs',
                                                             'MPlugArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn two arrays: the first contains the animCurves associated with this clip. The second contains the character member that is driven by this animCurve.',
                                                   'inArgs': [],
                                                   'outArgs': ['curves',
                                                               'associatedAttrs'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'associatedAttrs': ['&'],
                                                                      'curves': ['&']},
                                                   'types': {'associatedAttrs': 'MPlugArray',
                                                             'curves': 'MObjectArray'}}],
                          'getPostCycle': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\r\nReturn the value of this clip's post cycle attribute",
                                            'inArgs': [],
                                            'inverse': ('setPostCycle',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The value of this clip's post cycle attribute.",
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                          'getPreCycle': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\r\nReturn the value of this clip's pre cycle attribute",
                                           'inArgs': [],
                                           'inverse': ('setPreCycle',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': "The value of this clip's pre cycle attribute.",
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                          'getScale': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "\r\nReturn the value of this clip's scale attribute",
                                        'inArgs': [],
                                        'inverse': ('setScale', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': "The value of this clip's scale attribute.",
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                          'getSourceDuration': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nReturn the value of the start frame of this clip's source duration. The sourceStart and sourceDuration define the region of the animCurve that is treated as the clip.",
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': "The value of this clip's source duration.",
                                                                'qualifiers': [],
                                                                'type': 'MTime'},
                                                 'returnType': 'MTime',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                          'getSourceStart': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nReturn the value of the start frame of this clip's source clip. The sourceStart and sourceDuration define the region of the animCurve that is treated as the clip.",
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': "The value of this clip's source start frame.",
                                                             'qualifiers': [],
                                                             'type': 'MTime'},
                                              'returnType': 'MTime',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                          'getStartFrame': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nReturn the value of this clip's start frame",
                                             'inArgs': [],
                                             'inverse': ('setStartFrame',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': "The value of this clip's start frame.",
                                                            'qualifiers': [],
                                                            'type': 'MTime'},
                                             'returnType': 'MTime',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                          'getTrack': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturn the track number for the clip. Track indices are one-based. If a track index of zero is returned, it indicates that a track has not yet been assigned to the clip.',
                                        'inArgs': [],
                                        'inverse': ('setTrack', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': "The index of this clip's track",
                                                       'qualifiers': [],
                                                       'type': 'int'},
                                        'returnType': 'int',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                          'getWeight': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': "\r\nReturn the value of this clip's weight attribute",
                                         'inArgs': [],
                                         'inverse': ('setWeight', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': "The value of this clip's weight attribute.",
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'isInstancedClip': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn true or false as to whether the clip node represents the source clip or an instanced clip. All clips maintained by the clipScheduler node and visible in the TraX editor are instanced clips. All clips maintained by the clipLibrary node and visible in the Visor are non-instanced clips, also called "Source Clips". Each instanced clip has a corresponding source clip.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'True or false as to whether the clip is an instanced clip.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'isPose': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn true or false as to whether the clip node represents a pose.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'True or false as to whether the clip is a pose.',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                          'setAbsolute': [{'argInfo': {'abs': {'doc': 'true if absolute, false if relative ',
                                                               'type': 'bool'},
                                                       'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                               'type': 'MDGModifier'}},
                                           'args': [('abs',
                                                     'bool',
                                                     'in'),
                                                    ('mod',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'mod': None},
                                           'deprecated': True,
                                           'doc': '\n This method is obsolete. \n',
                                           'inArgs': ['abs', 'mod'],
                                           'inverse': ('getAbsolute',
                                                       True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'abs': [],
                                                              'mod': ['*']},
                                           'types': {'abs': 'bool',
                                                     'mod': 'MDGModifier'}}],
                          'setAbsoluteChannelSettings': [{'argInfo': {'absoluteChannels': {'doc': 'array containing the absolute channels to be set ',
                                                                                           'type': 'MIntArray'},
                                                                      'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                                              'type': 'MDGModifier'}},
                                                          'args': [('absoluteChannels',
                                                                    'MIntArray',
                                                                    'in'),
                                                                   ('mod',
                                                                    'MDGModifier',
                                                                    'in')],
                                                          'defaults': {'mod': None},
                                                          'deprecated': False,
                                                          'doc': '\r\nSet which channels of the clip are absolute and which are relative. The length of the specified array should be equal to the number of members in the character. A value of one in the array indicates absolute and a value of 0 indicates relative.',
                                                          'inArgs': ['absoluteChannels',
                                                                     'mod'],
                                                          'inverse': ('getAbsoluteChannelSettings',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'absoluteChannels': ['const',
                                                                                                  '&'],
                                                                             'mod': ['*']},
                                                          'types': {'absoluteChannels': 'MIntArray',
                                                                    'mod': 'MDGModifier'}}],
                          'setCycle': [{'argInfo': {'cycle': {'doc': 'cycle value ',
                                                              'type': 'double'},
                                                    'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                            'type': 'MDGModifier'}},
                                        'args': [('cycle',
                                                  'double',
                                                  'in'),
                                                 ('mod',
                                                  'MDGModifier',
                                                  'in')],
                                        'defaults': {'mod': None},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': ['cycle', 'mod'],
                                        'inverse': ('getCycle', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'cycle': [],
                                                           'mod': ['*']},
                                        'types': {'cycle': 'double',
                                                  'mod': 'MDGModifier'}}],
                          'setEnabled': [{'argInfo': {'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                              'type': 'MDGModifier'},
                                                      'val': {'doc': 'enable value ',
                                                              'type': 'bool'}},
                                          'args': [('val', 'bool', 'in'),
                                                   ('mod',
                                                    'MDGModifier',
                                                    'in')],
                                          'defaults': {'mod': None},
                                          'deprecated': False,
                                          'doc': '\r\nSpecify whether or not the clip is enabled. Note: should not be called for source clips since the enabled attribute is ignored on source clips.',
                                          'inArgs': ['val', 'mod'],
                                          'inverse': ('getEnabled', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'mod': ['*'],
                                                             'val': []},
                                          'types': {'mod': 'MDGModifier',
                                                    'val': 'bool'}}],
                          'setPoseClip': [{'argInfo': {'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                               'type': 'MDGModifier'},
                                                       'state': {'doc': 'true, to tag the clip as a pose ',
                                                                 'type': 'bool'}},
                                           'args': [('state',
                                                     'bool',
                                                     'in'),
                                                    ('mod',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'mod': None},
                                           'deprecated': False,
                                           'doc': '\r\nSpecify whether or not this clip node should be tagged as a pose rather than a clip. By default, clip nodes are not poses.',
                                           'inArgs': ['state', 'mod'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'mod': ['*'],
                                                              'state': []},
                                           'types': {'mod': 'MDGModifier',
                                                     'state': 'bool'}}],
                          'setPostCycle': [{'argInfo': {'cycle': {'doc': 'cycle value ',
                                                                  'type': 'double'},
                                                        'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                                'type': 'MDGModifier'}},
                                            'args': [('cycle',
                                                      'double',
                                                      'in'),
                                                     ('mod',
                                                      'MDGModifier',
                                                      'in')],
                                            'defaults': {'mod': None},
                                            'deprecated': False,
                                            'doc': '\r\nSpecify the post cycle value for the clip.',
                                            'inArgs': ['cycle', 'mod'],
                                            'inverse': ('getPostCycle',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'cycle': [],
                                                               'mod': ['*']},
                                            'types': {'cycle': 'double',
                                                      'mod': 'MDGModifier'}}],
                          'setPreCycle': [{'argInfo': {'cycle': {'doc': 'cycle value ',
                                                                 'type': 'double'},
                                                       'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                               'type': 'MDGModifier'}},
                                           'args': [('cycle',
                                                     'double',
                                                     'in'),
                                                    ('mod',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'mod': None},
                                           'deprecated': False,
                                           'doc': '\r\nSpecify the pre cycle value for the clip.',
                                           'inArgs': ['cycle', 'mod'],
                                           'inverse': ('getPreCycle',
                                                       True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'cycle': [],
                                                              'mod': ['*']},
                                           'types': {'cycle': 'double',
                                                     'mod': 'MDGModifier'}}],
                          'setScale': [{'argInfo': {'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                            'type': 'MDGModifier'},
                                                    'scale': {'doc': 'scale value ',
                                                              'type': 'double'}},
                                        'args': [('scale',
                                                  'double',
                                                  'in'),
                                                 ('mod',
                                                  'MDGModifier',
                                                  'in')],
                                        'defaults': {'mod': None},
                                        'deprecated': False,
                                        'doc': '\r\nSpecify a scale value for the clip.',
                                        'inArgs': ['scale', 'mod'],
                                        'inverse': ('getScale', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'mod': ['*'],
                                                           'scale': []},
                                        'types': {'mod': 'MDGModifier',
                                                  'scale': 'double'}}],
                          'setSourceData': [{'argInfo': {'duration': {'doc': 'source duration value ',
                                                                      'type': 'MTime'},
                                                         'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                                 'type': 'MDGModifier'},
                                                         'start': {'doc': 'source start frame value ',
                                                                   'type': 'MTime'}},
                                             'args': [('start',
                                                       'MTime',
                                                       'in'),
                                                      ('duration',
                                                       'MTime',
                                                       'in'),
                                                      ('mod',
                                                       'MDGModifier',
                                                       'in')],
                                             'defaults': {'mod': None},
                                             'deprecated': False,
                                             'doc': '\r\nSpecify the start frame and duration for the source clip associated with this clip.',
                                             'inArgs': ['start',
                                                        'duration',
                                                        'mod'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'duration': ['const',
                                                                             '&'],
                                                                'mod': ['*'],
                                                                'start': ['const',
                                                                          '&']},
                                             'types': {'duration': 'MTime',
                                                       'mod': 'MDGModifier',
                                                       'start': 'MTime'}}],
                          'setStartFrame': [{'argInfo': {'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                                 'type': 'MDGModifier'},
                                                         'start': {'doc': 'start frame value ',
                                                                   'type': 'MTime'}},
                                             'args': [('start',
                                                       'MTime',
                                                       'in'),
                                                      ('mod',
                                                       'MDGModifier',
                                                       'in')],
                                             'defaults': {'mod': None},
                                             'deprecated': False,
                                             'doc': '\r\nSpecify the start frame for the instanced clip. Note: should not be called for source clips since the start frame attribute is ignored on source clips.',
                                             'inArgs': ['start', 'mod'],
                                             'inverse': ('getStartFrame',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'mod': ['*'],
                                                                'start': ['const',
                                                                          '&']},
                                             'types': {'mod': 'MDGModifier',
                                                       'start': 'MTime'}}],
                          'setTrack': [{'argInfo': {'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                            'type': 'MDGModifier'},
                                                    'trackIndex': {'doc': 'the track number for the clip ',
                                                                   'type': 'int'}},
                                        'args': [('trackIndex',
                                                  'int',
                                                  'in'),
                                                 ('mod',
                                                  'MDGModifier',
                                                  'in')],
                                        'defaults': {'mod': None},
                                        'deprecated': False,
                                        'doc': '\r\nSpecify the one-based track number for the clip.',
                                        'inArgs': ['trackIndex', 'mod'],
                                        'inverse': ('getTrack', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'mod': ['*'],
                                                           'trackIndex': []},
                                        'types': {'mod': 'MDGModifier',
                                                  'trackIndex': 'int'}}],
                          'setWeight': [{'argInfo': {'mod': {'doc': 'modifier to use when calling this method from commands that support undo',
                                                             'type': 'MDGModifier'},
                                                     'wt': {'doc': 'weight value ',
                                                            'type': 'double'}},
                                         'args': [('wt', 'double', 'in'),
                                                  ('mod',
                                                   'MDGModifier',
                                                   'in')],
                                         'defaults': {'mod': None},
                                         'deprecated': False,
                                         'doc': '\r\nSpecify a weight value for the clip.',
                                         'inArgs': ['wt', 'mod'],
                                         'inverse': ('getWeight', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'mod': ['*'],
                                                            'wt': []},
                                         'types': {'mod': 'MDGModifier',
                                                   'wt': 'double'}}],
                          'sourceClip': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nReturn the source clip associated with the MFnClip's clip",
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'MObject containing the associated source clip.',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nFunction set type. \r\n',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': ('MFn',
                                                            'Type')},
                                    'returnType': ('MFn', 'Type'),
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}]},
              'pymelEnums': {}},
  'MFnComponent': {'enums': {},
                   'invertibles': [('setComplete', 'isComplete'),
                                   ('setWeight', 'weight')],
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClass name. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'componentType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the  MFn  type of the component.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The type',
                                                                 'qualifiers': [],
                                                                 'type': ('MFn',
                                                                          'Type')},
                                                  'returnType': ('MFn',
                                                                 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                               'elementCount': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the number of elements that this component contains.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of elements',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                               'hasWeights': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nQuery this component for the existance of attached weight data. Weight data will be added to a component as part of soft selection and/or symmetry. Note that this method does not test for the existance of external weight information (e.g. deformer weights stored in separate attributes).',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'isComplete': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the complete state of the component.',
                                               'inArgs': [],
                                               'inverse': ('setComplete',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'True if this component is complete, false otherwise',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                               'isEmpty': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermines if this component is empty, i.e. there are no index elements.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'True if empty, false otherwise',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                               'isEqual': [{'argInfo': {'component': {'doc': 'component to compare ',
                                                                      'type': 'MObject'}},
                                            'args': [('component',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCompares this component with the given component.',
                                            'inArgs': ['component'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'True if the components are equal, false otherwise',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'component': ['&']},
                                            'types': {'component': 'MObject'}}],
                               'setComplete': [{'argInfo': {'complete': {'doc': 'true sets the component as complete',
                                                                         'type': 'bool'}},
                                                'args': [('complete',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the complete state of the component.',
                                                'inArgs': ['complete'],
                                                'inverse': ('isComplete',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'complete': []},
                                                'types': {'complete': 'bool'}}],
                               'setWeight': [{'argInfo': {'index': {'doc': 'The element to set weight data for (note that this is the linear index between 0 and elementCount()-1) ',
                                                                    'type': 'int'},
                                                          'weight': {'doc': 'The new weight for the element',
                                                                     'type': 'MWeight'}},
                                              'args': [('index',
                                                        'int',
                                                        'in'),
                                                       ('weight',
                                                        'MWeight',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the weight data for a given element within this component.',
                                              'inArgs': ['index',
                                                         'weight'],
                                              'inverse': ('weight', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'index': [],
                                                                 'weight': ['const',
                                                                            '&']},
                                              'types': {'index': 'int',
                                                        'weight': 'MWeight'}}],
                               'setWeights': [{'argInfo': {'weight': {'doc': 'The new weight for all element',
                                                                      'type': 'MWeight'}},
                                               'args': [('weight',
                                                         'MWeight',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the weight data for all elements within this component.',
                                               'inArgs': ['weight'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'weight': ['const',
                                                                             '&']},
                                               'types': {'weight': 'MWeight'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'weight': [{'argInfo': {'index': {'doc': 'The element to return weight data for (note that this is the linear index between 0 and elementCount()-1) ',
                                                                 'type': 'int'}},
                                           'args': [('index',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the weight data for a given element within this component. Note that this method does not return external weight data (e.g. deformer weights stored in separate attributes).',
                                           'inArgs': ['index'],
                                           'inverse': ('setWeight',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The element weight data.',
                                                          'qualifiers': [],
                                                          'type': 'MWeight'},
                                           'returnType': 'MWeight',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'index': []},
                                           'types': {'index': 'int'}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'weight': 'getWeight'}},
  'MFnComponentListData': {'enums': {},
                           'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the component to extract',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nExtract the indicated component from the const instance.',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The indicated component ',
                                                                       'qualifiers': [],
                                                                       'type': 'MObject'},
                                                        'returnType': 'MObject',
                                                        'static': False,
                                                        'typeQualifiers': {'index': ['unsigned']},
                                                        'types': {'index': 'uint'}}],
                                       'add': [{'argInfo': {'obj': {'doc': 'an MObject containing the component to add',
                                                                    'type': 'MObject'}},
                                                'args': [('obj',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nAdd the given component to the component list.',
                                                'inArgs': ['obj'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'obj': ['&']},
                                                'types': {'obj': 'MObject'}}],
                                       'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nClass name. \r\n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'clear': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRemove all components from the component list',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                       'create': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to contain an empty component list.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The newly created MObject ',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                       'has': [{'argInfo': {'obj': {'doc': 'the MObject containing the component to look for ',
                                                                    'type': 'MObject'}},
                                                'args': [('obj',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermine if the instance of the component list contains the component represented by the given  MObject .',
                                                'inArgs': ['obj'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true if the component list contains the component, false otherwise ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'obj': ['const',
                                                                           '&']},
                                                'types': {'obj': 'MObject'}}],
                                       'length': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the number of components in the instance.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The number of components in the instance',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                       'remove': [{'argInfo': {'obj': {'doc': 'an MObject containing the component to remove',
                                                                       'type': 'MObject'}},
                                                   'args': [('obj',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRemove the given component from the component list.',
                                                   'inArgs': ['obj'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'obj': ['const',
                                                                              '&']},
                                                   'types': {'obj': 'MObject'}},
                                                  {'argInfo': {'index': {'doc': 'the index of the component to remove',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRemove the indicated component from the component list.',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nFunction set type. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MFn',
                                                                         'Type')},
                                                 'returnType': ('MFn',
                                                                'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                           'pymelEnums': {}},
  'MFnCompoundAttribute': {'enums': {},
                           'methods': {'addChild': [{'argInfo': {'child': {'doc': 'new child attribute',
                                                                           'type': 'MObject'}},
                                                     'args': [('child',
                                                               'MObject',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nAdd a child attribute under this compound attribute.',
                                                     'inArgs': ['child'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'child': ['const',
                                                                                  '&']},
                                                     'types': {'child': 'MObject'}}],
                                       'child': [{'argInfo': {'index': {'doc': 'index of child ',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet a child of this compound attribute.',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The child attribute',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}],
                                       'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nClass name. \r\n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'create': [{'argInfo': {'brief': {'doc': 'Short name of the attribute. ',
                                                                         'type': 'MString'},
                                                               'full': {'doc': 'Long name of the attribute. ',
                                                                        'type': 'MString'}},
                                                   'args': [('full',
                                                             'MString',
                                                             'in'),
                                                            ('brief',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nCreates a new compound attribute.',
                                                   'inArgs': ['full',
                                                              'brief'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Return status',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'brief': ['const',
                                                                                '&'],
                                                                      'full': ['const',
                                                                               '&']},
                                                   'types': {'brief': 'MString',
                                                             'full': 'MString'}}],
                                       'getAddAttrCmds': [{'argInfo': {'cmds': {'doc': 'string array to receive the adAttr commands ',
                                                                                'type': 'MStringArray'},
                                                                       'useLongNames': {'doc': 'if true, long attribute names are used rather than short',
                                                                                        'type': 'bool'}},
                                                           'args': [('cmds',
                                                                     'MStringArray',
                                                                     'out'),
                                                                    ('useLongNames',
                                                                     'bool',
                                                                     'in')],
                                                           'defaults': {'useLongNames': False},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns a string array containing the  addAttr  commands which would be required to recreate the attribute and all of its descendents on a node.',
                                                           'inArgs': ['useLongNames'],
                                                           'outArgs': ['cmds'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'cmds': ['&'],
                                                                              'useLongNames': []},
                                                           'types': {'cmds': 'MStringArray',
                                                                     'useLongNames': 'bool'}}],
                                       'numChildren': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the number of child attributes that this compound attribute has.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The number of children',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                       'removeChild': [{'argInfo': {'child': {'doc': 'child attribute to remove',
                                                                              'type': 'MObject'}},
                                                        'args': [('child',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRemove a child attribute from this compound attribute.',
                                                        'inArgs': ['child'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'child': ['const',
                                                                                     '&']},
                                                        'types': {'child': 'MObject'}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nFunction set type. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MFn',
                                                                         'Type')},
                                                 'returnType': ('MFn',
                                                                'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                           'pymelEnums': {}},
  'MFnContainerNode': {'enums': {'MPublishNodeType': {'valueDocs': {'childAnchor': 'published as child anchor',
                                                                    'generic': 'published as node (non-anchor)',
                                                                    'kChildAnchor': 'published as child anchor',
                                                                    'kGeneric': 'published as node (non-anchor)',
                                                                    'kParentAnchor': 'published as parent anchor',
                                                                    'parentAnchor': 'published as parent anchor'},
                                                      'values': "Enum('MPublishNodeType', {'kParentAnchor': 0, 'kChildAnchor': 1, 'kGeneric': 2})"}},
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nClass name. \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'clear': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nDelete all members of the container.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                   'getCurrentAsMObject': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nRetrieve the current container node.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'MObject'},
                                                            'returnType': 'MObject',
                                                            'static': True,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                   'getMembers': [{'argInfo': {'members': {'doc': 'array to store the result nodes',
                                                                           'type': 'MObjectArray'}},
                                                   'args': [('members',
                                                             'MObjectArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturn an array of the nodes included in this container.',
                                                   'inArgs': [],
                                                   'outArgs': ['members'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'members': ['&']},
                                                   'types': {'members': 'MObjectArray'}}],
                                   'getParentContainer': [{'argInfo': {'parent': {'doc': 'parent container, if found',
                                                                                  'type': 'MObject'}},
                                                           'args': [('parent',
                                                                     'MObject',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturn the parent container, if there is one. Otherwise return an empty  MObject',
                                                           'inArgs': [],
                                                           'outArgs': ['parent'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'parent': ['&']},
                                                           'types': {'parent': 'MObject'}}],
                                   'getPublishedNames': [{'argInfo': {'publishedNames': {'doc': 'array to store the result names ',
                                                                                         'type': 'MStringArray'},
                                                                      'unboundOnly': {'doc': 'if true, only return names that are not associated with a plug',
                                                                                      'type': 'bool'}},
                                                          'args': [('publishedNames',
                                                                    'MStringArray',
                                                                    'out'),
                                                                   ('unboundOnly',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturn a list of published names on the container. Depending on the arguments, either all published names or only unbound published names will be returned.',
                                                          'inArgs': ['unboundOnly'],
                                                          'outArgs': ['publishedNames'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'publishedNames': ['&'],
                                                                             'unboundOnly': []},
                                                          'types': {'publishedNames': 'MStringArray',
                                                                    'unboundOnly': 'bool'}}],
                                   'getPublishedNodes': [{'argInfo': {'nodes': {'doc': 'corresponding published node or a NULL MObject',
                                                                                'type': 'MObjectArray'},
                                                                      'publishedNames': {'doc': 'published names of the specified type ',
                                                                                         'type': 'MStringArray'},
                                                                      'type': {'doc': 'published node type of interest ',
                                                                               'type': ('MFnContainerNode',
                                                                                        'MPublishNodeType')}},
                                                          'args': [('type',
                                                                    ('MFnContainerNode',
                                                                     'MPublishNodeType'),
                                                                    'in'),
                                                                   ('publishedNames',
                                                                    'MStringArray',
                                                                    'out'),
                                                                   ('nodes',
                                                                    'MObjectArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturn a list of the published nodes of a given type. For any names that have assigned nodes, return the node at the corresponding array index. For any names that do not have assigned nodes, a NULL  MObject  will be at the corresponding array index.',
                                                          'inArgs': ['type'],
                                                          'outArgs': ['publishedNames',
                                                                      'nodes'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'nodes': ['&'],
                                                                             'publishedNames': ['&'],
                                                                             'type': []},
                                                          'types': {'nodes': 'MObjectArray',
                                                                    'publishedNames': 'MStringArray',
                                                                    'type': ('MFnContainerNode',
                                                                             'MPublishNodeType')}}],
                                   'getPublishedPlugs': [{'argInfo': {'publishedNames': {'doc': 'array to store the result names',
                                                                                         'type': 'MStringArray'},
                                                                      'publishedPlugs': {'doc': 'array to store the result plugs ',
                                                                                         'type': 'MPlugArray'}},
                                                          'args': [('publishedPlugs',
                                                                    'MPlugArray',
                                                                    'out'),
                                                                   ('publishedNames',
                                                                    'MStringArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturn two arrays: the first contains the plugs that have been published on this container. The second contains that published names for those plugs. There is a one-to-one correspondence between the plugs in the first array and the strings in the second.',
                                                          'inArgs': [],
                                                          'outArgs': ['publishedPlugs',
                                                                      'publishedNames'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'publishedNames': ['&'],
                                                                             'publishedPlugs': ['&']},
                                                          'types': {'publishedNames': 'MStringArray',
                                                                    'publishedPlugs': 'MPlugArray'}}],
                                   'getRootTransform': [{'argInfo': {'root': {'doc': 'root transform, if found',
                                                                              'type': 'MObject'}},
                                                         'args': [('root',
                                                                   'MObject',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturn the root transform, if there is one. Otherwise return an empty  MObject .',
                                                         'inArgs': [],
                                                         'outArgs': ['root'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'root': ['&']},
                                                         'types': {'root': 'MObject'}}],
                                   'getSubcontainers': [{'argInfo': {'subcontainers': {'doc': 'array to store the result nodes',
                                                                                       'type': 'MObjectArray'}},
                                                         'args': [('subcontainers',
                                                                   'MObjectArray',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturn an array of the container nodes included in this container.',
                                                         'inArgs': [],
                                                         'outArgs': ['subcontainers'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'subcontainers': ['&']},
                                                         'types': {'subcontainers': 'MObjectArray'}}],
                                   'isCurrent': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturn whether the container node managed by this function set is the current container',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'True if the container is the current container, false otherwise',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'status': ['*']},
                                                  'types': {}}],
                                   'makeCurrent': [{'argInfo': {'isCurrent': {'doc': 'Specifies whether this container shall be current',
                                                                              'type': 'bool'}},
                                                    'args': [('isCurrent',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {'isCurrent': True},
                                                    'deprecated': False,
                                                    'doc': '\nSet or clear whether the container managed by this function set is denoted as the the current container. If the flag is true and the container is allowed to be current, then the current container is set to be the container. Otherwise, if the container managed by the function set is the current container, then the current container is cleared.',
                                                    'inArgs': ['isCurrent'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'isCurrent': []},
                                                    'types': {'isCurrent': 'bool'}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nFunction set type. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                       'pymelEnums': {'MPublishNodeType': "Enum('MPublishNodeType', [('parentAnchor', 0), ('kParentAnchor', 0), ('childAnchor', 1), ('kChildAnchor', 1), ('generic', 2), ('kGeneric', 2)], multiKeys=True)"}},
  'MFnCurveSegmentManip': {'enums': {},
                           'invertibles': [('setStartParameter',
                                            'startParameter'),
                                           ('setEndParameter',
                                            'endParameter')],
                           'methods': {'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nClass name. \n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'connectToCurvePlug': [{'argInfo': {'curvePlug': {'doc': 'the curve plug',
                                                                                         'type': 'MPlug'}},
                                                               'args': [('curvePlug',
                                                                         'MPlug',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nConnect to the curve plug. The data type corresponding to the curvePlug is  MFnData::kNurbsCurve .',
                                                               'inArgs': ['curvePlug'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'curvePlug': ['&']},
                                                               'types': {'curvePlug': 'MPlug'}}],
                                       'connectToEndParamPlug': [{'argInfo': {'endParamPlug': {'doc': 'the endParam plug',
                                                                                               'type': 'MPlug'}},
                                                                  'args': [('endParamPlug',
                                                                            'MPlug',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nConnect to the endParam plug. The data type corresponding to the endParamPlug is a double.',
                                                                  'inArgs': ['endParamPlug'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'endParamPlug': ['&']},
                                                                  'types': {'endParamPlug': 'MPlug'}}],
                                       'connectToStartParamPlug': [{'argInfo': {'startParamPlug': {'doc': 'the startParam plug',
                                                                                                   'type': 'MPlug'}},
                                                                    'args': [('startParamPlug',
                                                                              'MPlug',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\nConnect to the startParam plug. The data type corresponding to the startParamPlug is a double.',
                                                                    'inArgs': ['startParamPlug'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'startParamPlug': ['&']},
                                                                    'types': {'startParamPlug': 'MPlug'}}],
                                       'create': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\nCreates a new CurveSegmentManip. This function set's object is set to be the new manipulator.",
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Newly created CurveSegmentManip',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}},
                                                  {'argInfo': {'endParamName': {'doc': 'Label for the endParam value which appears in the feedback line. ',
                                                                                'type': 'MString'},
                                                               'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                             'type': 'MString'},
                                                               'startParamName': {'doc': 'Label for the startParam value which appears in the feedback line. ',
                                                                                  'type': 'MString'}},
                                                   'args': [('manipName',
                                                             'MString',
                                                             'in'),
                                                            ('startParamName',
                                                             'MString',
                                                             'in'),
                                                            ('endParamName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\nCreates a new CurveSegmentManip. This function set's object is set to be the new manipulator.",
                                                   'inArgs': ['manipName',
                                                              'startParamName',
                                                              'endParamName'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Newly created CurveSegmentManip.',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'endParamName': ['const',
                                                                                       '&'],
                                                                      'manipName': ['const',
                                                                                    '&'],
                                                                      'startParamName': ['const',
                                                                                         '&']},
                                                   'types': {'endParamName': 'MString',
                                                             'manipName': 'MString',
                                                             'startParamName': 'MString'}}],
                                       'curveIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the index of the curve. The data type corresponding to this index is  MFnData::kNurbsCurve .',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Curve index',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                       'endParamIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the index of the end parameter of the CurveSegmentManip. The data type corresponding this index is a double.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'End parameter index',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                       'endParameter': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the end parameter.',
                                                         'inArgs': [],
                                                         'inverse': ('setEndParameter',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'End parameter',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                       'setEndParameter': [{'argInfo': {'endParameter': {'doc': 'the end parameter',
                                                                                         'type': 'double'}},
                                                            'args': [('endParameter',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSets the end parameter.',
                                                            'inArgs': ['endParameter'],
                                                            'inverse': ('endParameter',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'endParameter': []},
                                                            'types': {'endParameter': 'double'}}],
                                       'setStartParameter': [{'argInfo': {'startParameter': {'doc': 'the start parameter',
                                                                                             'type': 'double'}},
                                                              'args': [('startParameter',
                                                                        'double',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the start parameter.',
                                                              'inArgs': ['startParameter'],
                                                              'inverse': ('startParameter',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'startParameter': []},
                                                              'types': {'startParameter': 'double'}}],
                                       'startParamIndex': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturns the index of the start parameter of the CurveSegmentManip. The data type corresponding to this index is a double.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Start parameter index',
                                                                           'qualifiers': [],
                                                                           'type': 'int'},
                                                            'returnType': 'int',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                       'startParameter': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturns the start parameter.',
                                                           'inArgs': [],
                                                           'inverse': ('setStartParameter',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' start parameter  ',
                                                                          'qualifiers': [],
                                                                          'type': 'double'},
                                                           'returnType': 'double',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nFunction set type. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MFn',
                                                                         'Type')},
                                                 'returnType': ('MFn',
                                                                'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                           'pymelEnums': {},
                           'pymelMethods': {'endParameter': 'getEndParameter',
                                            'startParameter': 'getStartParameter'}},
  'MFnDagNode': {'enums': {'MObjectColorType': {'valueDocs': {'RGBColor': 'Use RGB color.',
                                                              'defaultColor': 'Use preference color.',
                                                              'indexColor': 'Use index color.',
                                                              'kUseDefaultColor': 'Use preference color.',
                                                              'kUseIndexColor': 'Use index color.',
                                                              'kUseRGBColor': 'Use RGB color.'},
                                                'values': "Enum('MObjectColorType', {'kUseDefaultColor': 0, 'kUseIndexColor': 1, 'kUseRGBColor': 2})"}},
                 'invertibles': [('setInstanceable', 'isInstanceable'),
                                 ('setObjectColor', 'objectColor'),
                                 ('setIntermediateObject',
                                  'isIntermediateObject'),
                                 ('setObjectColorType', 'objectColorType')],
                 'methods': {'activeColor': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines the active color used by this node. The active color is the active color for this kind of dag node.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The active color.',
                                                             'qualifiers': [],
                                                             'type': 'MColor'},
                                              'returnType': 'MColor',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                             'addChild': [{'argInfo': {'child': {'doc': 'The node to be added as child ',
                                                                 'type': 'MObject'},
                                                       'index': {'doc': 'The index that the child should be position. Defaulted to MFnDagNode::kNextPos ',
                                                                 'type': 'uint'},
                                                       'keepExistingParents': {'doc': 'Should the child be instanced?',
                                                                               'type': 'bool'}},
                                           'args': [('child',
                                                     'MObject',
                                                     'in'),
                                                    ('index',
                                                     'uint',
                                                     'in'),
                                                    ('keepExistingParents',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'index': 'kNextPos',
                                                        'keepExistingParents': False},
                                           'deprecated': False,
                                           'doc': '\r\nMakes the given DAG Node a child of the DAG Node to which this instance of the Function Set is attached.',
                                           'inArgs': ['child',
                                                      'index',
                                                      'keepExistingParents'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'child': ['&'],
                                                              'index': ['unsigned'],
                                                              'keepExistingParents': []},
                                           'types': {'child': 'MObject',
                                                     'index': 'uint',
                                                     'keepExistingParents': 'bool'}}],
                             'boundingBox': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the bounding box for the dag node in object space.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The bounding box for the dag node',
                                                             'qualifiers': [],
                                                             'type': 'MBoundingBox'},
                                              'returnType': 'MBoundingBox',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                             'child': [{'argInfo': {'i': {'doc': 'Index to the child Node ',
                                                          'type': 'uint'}},
                                        'args': [('i', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nQueries the DAG Node attached to the Function Set for the child Node corresponding to the given index.',
                                        'inArgs': ['i'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The child Node for the given index.',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           'i': ['unsigned']},
                                        'types': {'i': 'uint'}}],
                             'childCount': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines the number of child Nodes of the Node. Used to determine the upper bound for the child index (max index = childCount-1).',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Number of child Nodes.',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nClass name. \r\n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'create': [{'argInfo': {'parent': {'doc': 'the parent of the node to be created ',
                                                                'type': 'MObject'},
                                                     'typeId': {'doc': 'type id of the node to be created ',
                                                                'type': 'MTypeId'}},
                                         'args': [('typeId',
                                                   'MTypeId',
                                                   'in'),
                                                  ('parent',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parent': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nCreates a new DAG node with the given type tag. The new node is placed into the DAG.',
                                         'inArgs': ['typeId', 'parent'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'A pointer to the new dependency node object or the transform added above it.',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'parent': ['&'],
                                                            'typeId': ['const',
                                                                       '&']},
                                         'types': {'parent': 'MObject',
                                                   'typeId': 'MTypeId'}},
                                        {'argInfo': {'name': {'doc': 'the name to be assigned to the new node If the node\'s name is not unique, it will be given a unique name by changing its numerical suffix. For example, if this node is called "myNode" and a node by the same name exists, this node will be renamed to "myNode1". ',
                                                              'type': 'MString'},
                                                     'parent': {'doc': 'the parent of the node to be created ',
                                                                'type': 'MObject'},
                                                     'typeId': {'doc': 'type id of the node to be created ',
                                                                'type': 'MTypeId'}},
                                         'args': [('typeId',
                                                   'MTypeId',
                                                   'in'),
                                                  ('name',
                                                   'MString',
                                                   'in'),
                                                  ('parent',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parent': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nCreates a new DAG node with the given type tag. The new node is placed into the DAG.',
                                         'inArgs': ['typeId',
                                                    'name',
                                                    'parent'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'A pointer to the new dependency node object or the transform added above it.',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'name': ['const',
                                                                     '&'],
                                                            'parent': ['&'],
                                                            'typeId': ['const',
                                                                       '&']},
                                         'types': {'name': 'MString',
                                                   'parent': 'MObject',
                                                   'typeId': 'MTypeId'}},
                                        {'argInfo': {'parent': {'doc': 'The DAG parent of this node. ',
                                                                'type': 'MObject'},
                                                     'type': {'doc': 'Name of the type of DAG node to create. ',
                                                              'type': 'MString'}},
                                         'args': [('type',
                                                   'MString',
                                                   'in'),
                                                  ('parent',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parent': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nCreates a new DAG node with the given type tag. The new node is placed into the DAG.',
                                         'inArgs': ['type', 'parent'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The new dependency node or the transform added above it.',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'parent': ['&'],
                                                            'type': ['const',
                                                                     '&']},
                                         'types': {'parent': 'MObject',
                                                   'type': 'MString'}},
                                        {'argInfo': {'name': {'doc': 'Name to be assigned to the new node. If the node\'s name is not unique it will be given a unique name by adding a numerical suffix. For example, if name contains "myNode" and a node with that name already exists, the new node will be named "myNode1". ',
                                                              'type': 'MString'},
                                                     'parent': {'doc': 'The DAG parent of this node. ',
                                                                'type': 'MObject'},
                                                     'type': {'doc': 'Name of the type of DAG node to create. ',
                                                              'type': 'MString'}},
                                         'args': [('type',
                                                   'MString',
                                                   'in'),
                                                  ('name',
                                                   'MString',
                                                   'in'),
                                                  ('parent',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parent': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nCreates a new DAG node with the given type tag. The new node is placed into the DAG.',
                                         'inArgs': ['type',
                                                    'name',
                                                    'parent'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The new dependency node or the transform added above it.',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'name': ['const',
                                                                     '&'],
                                                            'parent': ['&'],
                                                            'type': ['const',
                                                                     '&']},
                                         'types': {'name': 'MString',
                                                   'parent': 'MObject',
                                                   'type': 'MString'}}],
                             'dagPath': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the DagPath to which the Function Set is attached. The difference between this method and the method  getPath  above is that this one will fail if the function set is not attached to a dag path.  getPath  will find a dag path if the function set is not attached to one.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'An MDagPath that references the object to which the Function Set is attached. If the function set is not attached to a dag path an uninitialized MDagPath will be returned.',
                                                         'qualifiers': [],
                                                         'type': 'MDagPath'},
                                          'returnType': 'MDagPath',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                             'dagRoot': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermines the root of the first DAG Path to the DAG Node attached to the Function Set.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The DAG root',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                             'dormantColor': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermines the dormant color used by this node. The order to determine the dormant color is:  \n hilite color if hilite color is used  \n object color if user defined object color is used  \n the dormant color for this kind of dag node \n \n Parameters: \n \n [out]  ReturnStatus  Status code. \n \n \n Returns: The dormant color. \n Status Codes: \n MS::kSuccess  Success  \n MS::kFailure  No valid DAG Node attached to Function Set  \n \n \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The dormant color.',
                                                              'qualifiers': [],
                                                              'type': 'MColor'},
                                               'returnType': 'MColor',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                             'drawOverrideColor': [{'argInfo': {'color': {'doc': 'The draw override color. ',
                                                                          'type': 'MColor'}},
                                                    'args': [('color',
                                                              'MColor',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDetermines the draw override color used by this node. Returns true if there is a draw override color. Otherwise, returns false and color parameter is not changed.',
                                                    'inArgs': [],
                                                    'outArgs': ['color'],
                                                    'returnInfo': {'doc': 'True if a draw override color is used.',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'color': ['&']},
                                                    'types': {'color': 'MColor'}}],
                             'drawOverrideEnabled': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nDetermines whether or not draw override is turned on for this node.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True if draw override is turned on.',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                             'drawOverrideIsReference': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDetermines whether or not Display Type of the draw override is Reference for this node.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'True if Display Type is Reference.',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                             'drawOverrideIsTemplate': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nDetermines whether or not Display Type of the draw override is Template for this node.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'True if Display Type is Template.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                             'duplicate': [{'argInfo': {'instance': {'doc': 'Duplicate using instancing if true ',
                                                                     'type': 'bool'},
                                                        'leafInstance': {'doc': 'Instance only at the leaf level if true ',
                                                                         'type': 'bool'}},
                                            'args': [('instance',
                                                      'bool',
                                                      'in'),
                                                     ('leafInstance',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'instance': False,
                                                         'leafInstance': False},
                                            'deprecated': False,
                                            'doc': '\r\nThis method duplicates the DAG hierarchy rooted at the current node. The copy will have the same parent, if any, as the original node.',
                                            'inArgs': ['instance',
                                                       'leafInstance'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A reference to the newly created node.',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'instance': [],
                                                               'leafInstance': []},
                                            'types': {'instance': 'bool',
                                                      'leafInstance': 'bool'}}],
                             'fullPathName': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn a string representing the full path from the root of the dag to this object.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The full path name',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                             'getAllPaths': [{'argInfo': {'paths': {'doc': 'Array of all DAG Paths that are found (implicit return)',
                                                                    'type': 'MDagPathArray'}},
                                              'args': [('paths',
                                                        'MDagPathArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines all DAG Paths to the DAG Node attached to the Function Set.',
                                              'inArgs': [],
                                              'outArgs': ['paths'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'paths': ['&']},
                                              'types': {'paths': 'MDagPathArray'}}],
                             'getConnectedSetsAndMembers': [{'argInfo': {'comps': {'doc': 'Storage for the components that are in the corresponding set ',
                                                                                   'type': 'MObjectArray'},
                                                                         'instanceNumber': {'doc': 'The instance number of the mesh to query ',
                                                                                            'type': 'uint'},
                                                                         'renderableSetsOnly': {'doc': 'If true then this method will only return renderable sets',
                                                                                                'type': 'bool'},
                                                                         'sets': {'doc': 'Storage for the sets ',
                                                                                  'type': 'MObjectArray'}},
                                                             'args': [('instanceNumber',
                                                                       'uint',
                                                                       'in'),
                                                                      ('sets',
                                                                       'MObjectArray',
                                                                       'out'),
                                                                      ('comps',
                                                                       'MObjectArray',
                                                                       'out'),
                                                                      ('renderableSetsOnly',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturns all the sets connected to the specified instance of this DAG object. For each set in the "sets" array there is a corresponding entry in the "comps" array which are all the components in that set. If the entire object is in a set, then the corresponding entry in the comps array will have no elements in it.',
                                                             'inArgs': ['instanceNumber',
                                                                        'renderableSetsOnly'],
                                                             'outArgs': ['sets',
                                                                         'comps'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'comps': ['&'],
                                                                                'instanceNumber': ['unsigned'],
                                                                                'renderableSetsOnly': [],
                                                                                'sets': ['&']},
                                                             'types': {'comps': 'MObjectArray',
                                                                       'instanceNumber': 'uint',
                                                                       'renderableSetsOnly': 'bool',
                                                                       'sets': 'MObjectArray'}}],
                             'getPath': [{'argInfo': {'path': {'doc': 'The DAG Path that is found (implicit return)',
                                                               'type': 'MDagPath'}},
                                          'args': [('path',
                                                    'MDagPath',
                                                    'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns a DAG Path to the DAG Node attached to the Function Set. The difference between this method and the method  dagPath  below is that this one will not fail if the function set is not attached to a dag path, it will always return  a  path to the node.  dagPath  will fail if the function set is not attached to a dag path.',
                                          'inArgs': [],
                                          'outArgs': ['path'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'path': ['&']},
                                          'types': {'path': 'MDagPath'}}],
                             'hasChild': [{'argInfo': {'node': {'doc': 'node to check ',
                                                                'type': 'MObject'}},
                                           'args': [('node',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nDetermines whether or not the given Node is a child of the DAG Node attached to the Function Set.',
                                           'inArgs': ['node'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'true if the node is a child, false otherwise.',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'node': ['const',
                                                                       '&']},
                                           'types': {'node': 'MObject'}}],
                             'hasParent': [{'argInfo': {'node': {'doc': 'Potential parent node ',
                                                                 'type': 'MObject'}},
                                            'args': [('node',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermines whether or not the given Node is a parent of the DAG Node attached to the Function Set.',
                                            'inArgs': ['node'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true if the node is a parent, false otherwise.',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'node': ['const',
                                                                        '&']},
                                            'types': {'node': 'MObject'}}],
                             'hiliteColor': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines the current hilite color used by the node.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The current hilite color.',
                                                             'qualifiers': [],
                                                             'type': 'MColor'},
                                              'returnType': 'MColor',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                             'inModel': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermines whether or not the DAG Node is in the model.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'true if the node in the model, false otherwise.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                             'inUnderWorld': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermines whether or not the DAG Node is an underworld node. (An example of an underworld node is a  curve on surface .)',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if the node is an underworld node, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                             'instanceCount': [{'argInfo': {'total': {'doc': 'Indirect instance flag ',
                                                                      'type': 'bool'}},
                                                'args': [('total',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'total': True},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines the number of times the Node attached to the Function Set is instanced.',
                                                'inArgs': ['total'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Number of instances (direct or indirect according to indirect instance flag).',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'total': []},
                                                'types': {'total': 'bool'}}],
                             'isChildOf': [{'argInfo': {'node': {'doc': 'node to check ',
                                                                 'type': 'MObject'}},
                                            'args': [('node',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermines whether or not the DAG Node attached to the Function Set is a child of the given node.',
                                            'inArgs': ['node'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true is a child, false otherwise.',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'node': ['const',
                                                                        '&']},
                                            'types': {'node': 'MObject'}}],
                             'isInstanceable': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if the DAG node can be instanced, and false otherwise.',
                                                 'inArgs': [],
                                                 'inverse': ('setInstanceable',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'true if the DAG node is instanceable, false otherwise.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                             'isInstanced': [{'argInfo': {'indirect': {'doc': 'Indirect instance flag ',
                                                                       'type': 'bool'}},
                                              'args': [('indirect',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'indirect': True},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines whether the DAG Node attached to the Function Set is directly or indirectly instanced.',
                                              'inArgs': ['indirect'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'true if the node is instanced (directly or indirectly according to indirect instance flag), false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'indirect': []},
                                              'types': {'indirect': 'bool'}}],
                             'isInstancedAttribute': [{'argInfo': {'attribute': {'doc': 'The attribute to test. ',
                                                                                 'type': 'MObject'}},
                                                       'args': [('attribute',
                                                                 'MObject',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns true if the specified attribute is instanced. An instanced attribute is an array attribute whose index depends upon which instance of the node is being referred to.',
                                                       'inArgs': ['attribute'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A boolean value indicating whether the attribute is instanced',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'attribute': ['const',
                                                                                        '&']},
                                                       'types': {'attribute': 'MObject'}}],
                             'isIntermediateObject': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns true if this object is an intermediate in a geometry calculation.',
                                                       'inArgs': [],
                                                       'inverse': ('setIntermediateObject',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'True if this is an intermediate object.',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                             'isParentOf': [{'argInfo': {'node': {'doc': 'node to check ',
                                                                  'type': 'MObject'}},
                                             'args': [('node',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermines whether or not the DAG Node attached to the Function Set is a parent of the given node.',
                                             'inArgs': ['node'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'true is a parent, false otherwise.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'node': ['const',
                                                                         '&']},
                                             'types': {'node': 'MObject'}}],
                             'model': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The model in which the DAG Node resides.',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                             'objectColor': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': True,
                                              'doc': '\n This method is obsolete. \n',
                                              'inArgs': [],
                                              'inverse': ('setObjectColor',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Index for current user defined inactive color (0 - 7)',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                             'objectColorIndex': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines the index for the current user defined inactive color used by the node. Valid indices are from 0 to 7.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Index for current user defined inactive color (0 - 7)',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                             'objectColorRGB': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nDetermines the RGB color for the current user defined inactive color used by the node.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'MColor defining the current RGB color',
                                                                'qualifiers': [],
                                                                'type': 'MColor'},
                                                 'returnType': 'MColor',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                             'objectColorType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermines whether or not the user defined inactive color will be used for the node, or whether the default inactive color will be used.',
                                                  'inArgs': [],
                                                  'inverse': ('setObjectColorType',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' MFnDagNode::kUseDefaultColor if using the the color defined in the color preferences  MFnDagNode::kUseIndexColor if using the inactive indexed object color  MFnDagNode::kUseRGBColor if using the inactive RGB object color  ',
                                                                 'qualifiers': [],
                                                                 'type': ('MFnDagNode',
                                                                          'MObjectColorType')},
                                                  'returnType': ('MFnDagNode',
                                                                 'MObjectColorType'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                             'parent': [{'argInfo': {'i': {'doc': 'Index to the parent Node ',
                                                           'type': 'uint'}},
                                         'args': [('i', 'uint', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nQueries the DAG Node attached to the Function Set for the parent Node corresponding to the given index.',
                                         'inArgs': ['i'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The parent Node for the given index.',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'i': ['unsigned']},
                                         'types': {'i': 'uint'}}],
                             'parentCount': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines the number of parent Nodes of the Node. Used to determine the upper bound for the parent index (max index = parentCount-1).',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Number of parent Nodes.',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                             'partialPathName': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn a string representing the partial path from the root of the dag to this object.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The partial path name',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                             'removeChild': [{'argInfo': {'child': {'doc': 'The Node to be removed as child',
                                                                    'type': 'MObject'}},
                                              'args': [('child',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRemoves the given DAG Node from the parent. Once the child is removed, all children at higher indices would shift 1 position to the left.',
                                              'inArgs': ['child'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'child': ['&']},
                                              'types': {'child': 'MObject'}}],
                             'removeChildAt': [{'argInfo': {'index': {'doc': 'The index of the child.',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRemoves the child at the given index from the parent. Once the child is removed, all children at higher indices would shift 1 position to the left.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                             'setInstanceable': [{'argInfo': {'how': {'doc': 'true if the node should be made instanceable, false to make the node noninstanceable.',
                                                                      'type': 'bool'}},
                                                  'args': [('how',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets whether or not the DAG node is instanceable. If the node is marked as noninstanceable, then if Maya attempts to create instances on the node the instancing operation will not succeed and instead an error will be reported. A node cannot be marked non-instanceable if it or any of its children are currently instanced.  MS::kFailure  will be returned it this occurs. The default instanceable state for newly created nodes if true, meaning that nodes can be instanced by default.',
                                                  'inArgs': ['how'],
                                                  'inverse': ('isInstanceable',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'how': ['const']},
                                                  'types': {'how': 'bool'}}],
                             'setIntermediateObject': [{'argInfo': {'isIntermediate': {'doc': 'whether to make this an intermediate object',
                                                                                       'type': 'bool'}},
                                                        'args': [('isIntermediate',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets whether this object is an intermediate in a geometry calculation.',
                                                        'inArgs': ['isIntermediate'],
                                                        'inverse': ('isIntermediateObject',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'isIntermediate': []},
                                                        'types': {'isIntermediate': 'bool'}}],
                             'setObject': [{'argInfo': {'objectPath': {'doc': 'DAG Path to Node to be attached.',
                                                                       'type': 'MDagPath'}},
                                            'args': [('objectPath',
                                                      'MDagPath',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nAttaches Function Set to the DAG Node that has the given DAG Path.',
                                            'inArgs': ['objectPath'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'objectPath': ['const',
                                                                              '&']},
                                            'types': {'objectPath': 'MDagPath'}},
                                           {'argInfo': {'object': {'doc': 'Target Node for attachment.',
                                                                   'type': 'MObject'}},
                                            'args': [('object',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nAttaches Function Set to given DAG Node.',
                                            'inArgs': ['object'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'object': ['&']},
                                            'types': {'object': 'MObject'}}],
                             'setObjectColor': [{'argInfo': {'index': {'doc': 'Index for current user color (0 - 7)',
                                                                       'type': 'int'}},
                                                 'args': [('index',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the index for the current user defined inactive color used by the node.',
                                                 'inArgs': ['index'],
                                                 'inverse': ('objectColor',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'index': []},
                                                 'types': {'index': 'int'}},
                                                {'argInfo': {'color': {'doc': 'Color to be set',
                                                                       'type': 'MColor'}},
                                                 'args': [('color',
                                                           'MColor',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the color value for the current user defined inactive color used by the node.',
                                                 'inArgs': ['color'],
                                                 'inverse': ('objectColor',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'color': ['const',
                                                                              '&']},
                                                 'types': {'color': 'MColor'}}],
                             'setObjectColorType': [{'argInfo': {'type': {'doc': 'MFnDagNode::kUseDefaultColor - the color defined in the color preferences will be used. MFnDagNode::kUseIndexColor - the user-defined inactive object indexed color will be used MFnDagNode::kUseRGBColor - the user defined inactive RGB object color will be used ',
                                                                          'type': ('MFnDagNode',
                                                                                   'MObjectColorType')}},
                                                     'args': [('type',
                                                               ('MFnDagNode',
                                                                'MObjectColorType'),
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets whether or not the user defined inactive object color will be used.',
                                                     'inArgs': ['type'],
                                                     'inverse': ('objectColorType',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'type': []},
                                                     'types': {'type': ('MFnDagNode',
                                                                        'MObjectColorType')}}],
                             'setUseObjectColor': [{'argInfo': {'useObjectColor': {'doc': 'True means the user defined inactive object color will be used',
                                                                                   'type': 'bool'}},
                                                    'args': [('useObjectColor',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': True,
                                                    'doc': '\n Deprecated: Use  MFnDagNode::setObjectColorType()  instead \r\nSets whether or not the user defined inactive object color will be used.',
                                                    'inArgs': ['useObjectColor'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'useObjectColor': []},
                                                    'types': {'useObjectColor': 'bool'}}],
                             'transformationMatrix': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the object space transformation matrix for this DAG node. In general, only transform nodes have matrices associated with them. Nodes such as shapes (geometry nodes) do not have transform matrices.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Object space transformation matrix.',
                                                                      'qualifiers': [],
                                                                      'type': 'MMatrix'},
                                                       'returnType': 'MMatrix',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nFunction set type. \r\n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': ('MFn',
                                                               'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                             'usingHiliteColor': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines whether or not the hilite color will be used for the node. hilite command sets this flag to true.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if using the hilite color.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                             'usingObjectColor': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': True,
                                                   'doc': '\n Deprecated: Use  MFnDagNode::objectColorType()  instead \r\nDetermines whether or not the user defined inactive color will be used for the node, or whether the default inactive color will be used.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if using the user defined inactive object color',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}]},
                 'pymelEnums': {'MObjectColorType': "Enum('MObjectColorType', [('defaultColor', 0), ('kUseDefaultColor', 0), ('indexColor', 1), ('kUseIndexColor', 1), ('RGBColor', 2), ('kUseRGBColor', 2)], multiKeys=True)"},
                 'pymelMethods': {'objectColor': 'getObjectColor',
                                  'objectColorType': 'getObjectColorType'}},
  'MFnData': {'enums': {'Type': {'valueDocs': {'NId': 'nId data, use',
                                               'NObject': 'nObject data, use',
                                               'any': 'Typically used when the data can be one of several types.',
                                               'componentList': 'Component List, use',
                                               'doubleArray': 'Double Array, use',
                                               'dynArrayAttrs': 'ArrayAttrs, use',
                                               'dynSweptGeometry': 'SweptGeometry, use',
                                               'floatArray': 'Float Array, use',
                                               'intArray': 'Int Array, use',
                                               'invalid': 'Invalid value.',
                                               'kAny': 'Typically used when the data can be one of several types.',
                                               'kComponentList': 'Component List, use',
                                               'kDoubleArray': 'Double Array, use',
                                               'kDynArrayAttrs': 'ArrayAttrs, use',
                                               'kDynSweptGeometry': 'SweptGeometry, use',
                                               'kFloatArray': 'Float Array, use',
                                               'kIntArray': 'Int Array, use',
                                               'kInvalid': 'Invalid value.',
                                               'kLast': 'Last value. It does not represent real data, but can be used to loop on all possible types',
                                               'kLattice': 'Lattice, use',
                                               'kMatrix': 'Matrix, use',
                                               'kMatrixArray': 'Matrix Array, use',
                                               'kMesh': 'Mesh, use',
                                               'kNId': 'nId data, use',
                                               'kNObject': 'nObject data, use',
                                               'kNumeric': 'Numeric, use',
                                               'kNurbsCurve': 'Nurbs Curve, use',
                                               'kNurbsSurface': 'Nurbs Surface, use',
                                               'kPlugin': 'Plugin Blind Data, use',
                                               'kPluginGeometry': 'Plugin Geometry, use',
                                               'kPointArray': 'Point Array, use',
                                               'kSphere': 'Sphere, use',
                                               'kString': 'String, use',
                                               'kStringArray': 'String Array, use',
                                               'kSubdSurface': 'Subdivision Surface, use',
                                               'kVectorArray': 'Vector Array, use',
                                               'last': 'Last value. It does not represent real data, but can be used to loop on all possible types',
                                               'lattice': 'Lattice, use',
                                               'matrix': 'Matrix, use',
                                               'matrixArray': 'Matrix Array, use',
                                               'mesh': 'Mesh, use',
                                               'numeric': 'Numeric, use',
                                               'nurbsCurve': 'Nurbs Curve, use',
                                               'nurbsSurface': 'Nurbs Surface, use',
                                               'plugin': 'Plugin Blind Data, use',
                                               'pluginGeometry': 'Plugin Geometry, use',
                                               'pointArray': 'Point Array, use',
                                               'sphere': 'Sphere, use',
                                               'string': 'String, use',
                                               'stringArray': 'String Array, use',
                                               'subdSurface': 'Subdivision Surface, use',
                                               'vectorArray': 'Vector Array, use'},
                                 'values': "Enum('Type', {'kInvalid': 0, 'kNumeric': 1, 'kPlugin': 2, 'kPluginGeometry': 3, 'kString': 4, 'kMatrix': 5, 'kStringArray': 6, 'kDoubleArray': 7, 'kFloatArray': 8, 'kIntArray': 9, 'kPointArray': 10, 'kVectorArray': 11, 'kMatrixArray': 12, 'kComponentList': 13, 'kMesh': 14, 'kLattice': 15, 'kNurbsCurve': 16, 'kNurbsSurface': 17, 'kSphere': 18, 'kDynArrayAttrs': 19, 'kDynSweptGeometry': 20, 'kSubdSurface': 21, 'kNObject': 22, 'kNId': 23, 'kAny': 24, 'kLast': 25})"}},
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nClass name. \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nFunction set type. \n',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': ('MFn',
                                                            'Type')},
                                    'returnType': ('MFn', 'Type'),
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}]},
              'pymelEnums': {'Type': "Enum('Type', [('invalid', 0), ('kInvalid', 0), ('numeric', 1), ('kNumeric', 1), ('plugin', 2), ('kPlugin', 2), ('pluginGeometry', 3), ('kPluginGeometry', 3), ('string', 4), ('kString', 4), ('matrix', 5), ('kMatrix', 5), ('stringArray', 6), ('kStringArray', 6), ('doubleArray', 7), ('kDoubleArray', 7), ('floatArray', 8), ('kFloatArray', 8), ('intArray', 9), ('kIntArray', 9), ('pointArray', 10), ('kPointArray', 10), ('vectorArray', 11), ('kVectorArray', 11), ('matrixArray', 12), ('kMatrixArray', 12), ('componentList', 13), ('kComponentList', 13), ('mesh', 14), ('kMesh', 14), ('lattice', 15), ('kLattice', 15), ('nurbsCurve', 16), ('kNurbsCurve', 16), ('nurbsSurface', 17), ('kNurbsSurface', 17), ('sphere', 18), ('kSphere', 18), ('dynArrayAttrs', 19), ('kDynArrayAttrs', 19), ('dynSweptGeometry', 20), ('kDynSweptGeometry', 20), ('subdSurface', 21), ('kSubdSurface', 21), ('NObject', 22), ('kNObject', 22), ('NId', 23), ('kNId', 23), ('any', 24), ('kAny', 24), ('last', 25), ('kLast', 25)], multiKeys=True)"}},
  'MFnDependencyNode': {'enums': {'MAttrClass': {'valueDocs': {'extensionAttr': 'Extension attribute which is part of all nodes of this or derived node types.',
                                                               'invalidAttr': 'None of the above.',
                                                               'kExtensionAttr': 'Extension attribute which is part of all nodes of this or derived node types.',
                                                               'kInvalidAttr': 'None of the above.',
                                                               'kLocalDynamicAttr': 'Dynamically added, applies to this specific node.',
                                                               'kNormalAttr': 'Static attribute which is part of the original definition for this node type.',
                                                               'localDynamicAttr': 'Dynamically added, applies to this specific node.',
                                                               'normalAttr': 'Static attribute which is part of the original definition for this node type.'},
                                                 'values': "Enum('MAttrClass', {'kLocalDynamicAttr': 1, 'kNormalAttr': 2, 'kExtensionAttr': 3, 'kInvalidAttr': 4})"},
                                  'MdgTimerMetric': {'valueDocs': {'kTimerMetric_callback': 'Time spent within node callbacks for this node.',
                                                                   'kTimerMetric_callbackNotViaAPI': 'Time spent in callbacks not registered through the API (i.e internal Maya callbacks).',
                                                                   'kTimerMetric_callbackViaAPI': 'Time spent in callbacks which were registered through the API.',
                                                                   'kTimerMetric_compute': 'Time spent within the compute method for this node.',
                                                                   'kTimerMetric_computeDuringCallback': "Time spent in this node's compute while executing node callbacks on any node.",
                                                                   'kTimerMetric_computeNotDuringCallback': 'Time spent in this nodes compute when not executing any node callbacks on any nodes.',
                                                                   'kTimerMetric_dirty': 'Time spent propogating dirty messages from this node.',
                                                                   'kTimerMetric_draw': 'Time spent drawing this node.',
                                                                   'kTimerMetric_fetch': 'Time spent fetching data from plugs.',
                                                                   'kTimerMetrics': 'Total number of metrics available.',
                                                                   'metric_callback': 'Time spent within node callbacks for this node.',
                                                                   'metric_callbackNotViaAPI': 'Time spent in callbacks not registered through the API (i.e internal Maya callbacks).',
                                                                   'metric_callbackViaAPI': 'Time spent in callbacks which were registered through the API.',
                                                                   'metric_compute': 'Time spent within the compute method for this node.',
                                                                   'metric_computeDuringCallback': "Time spent in this node's compute while executing node callbacks on any node.",
                                                                   'metric_computeNotDuringCallback': 'Time spent in this nodes compute when not executing any node callbacks on any nodes.',
                                                                   'metric_dirty': 'Time spent propogating dirty messages from this node.',
                                                                   'metric_draw': 'Time spent drawing this node.',
                                                                   'metric_fetch': 'Time spent fetching data from plugs.',
                                                                   'metrics': 'Total number of metrics available.'},
                                                     'values': "Enum('MdgTimerMetric', {'kTimerMetric_callback': 0, 'kTimerMetric_compute': 1, 'kTimerMetric_dirty': 2, 'kTimerMetric_draw': 3, 'kTimerMetric_fetch': 4, 'kTimerMetric_callbackViaAPI': 5, 'kTimerMetric_callbackNotViaAPI': 6, 'kTimerMetric_computeDuringCallback': 7, 'kTimerMetric_computeNotDuringCallback': 8, 'kTimerMetrics': 9})"},
                                  'MdgTimerState': {'valueDocs': {'invalidState': '',
                                                                  'kTimerInvalidState': '',
                                                                  'kTimerOff': '',
                                                                  'kTimerOn': '',
                                                                  'kTimerUninitialized': '',
                                                                  'off': '',
                                                                  'on': '',
                                                                  'uninitialized': ''},
                                                    'values': "Enum('MdgTimerState', {'kTimerOff': 0, 'kTimerOn': 1, 'kTimerUninitialized': 2, 'kTimerInvalidState': 3})"},
                                  'MdgTimerType': {'valueDocs': {'kTimerType_count': 'The number of operations that occurred. Ideally we should return an integer when this timer type is queried, but there are two advantages to using a double. 1) it keeps the interface consistent and 2) integer has a fixed upper bound of roughly four billion so using a double allows us to exceed this.',
                                                                 'kTimerType_inclusive': 'Time spent performing an operation including all time spent by child operations. For example, if we are drawing a node and that requires a compute, inclusive time is the time for the draw plus compute. Inclusive time measure wall-clock time as opposed to CPU time and the values are in seconds.',
                                                                 'kTimerType_self': 'Time spent performing an operation, not including any time spent by child operations. For example, if we are drawing a node and that requires a compute, self time will only include the time spent drawing and not the compute time. Self time measures wall-clock time as opposed to CPU time and the values are in seconds.',
                                                                 'kTimerTypes': 'The total number of timer types supported.',
                                                                 'type_count': 'The number of operations that occurred. Ideally we should return an integer when this timer type is queried, but there are two advantages to using a double. 1) it keeps the interface consistent and 2) integer has a fixed upper bound of roughly four billion so using a double allows us to exceed this.',
                                                                 'type_inclusive': 'Time spent performing an operation including all time spent by child operations. For example, if we are drawing a node and that requires a compute, inclusive time is the time for the draw plus compute. Inclusive time measure wall-clock time as opposed to CPU time and the values are in seconds.',
                                                                 'type_self': 'Time spent performing an operation, not including any time spent by child operations. For example, if we are drawing a node and that requires a compute, self time will only include the time spent drawing and not the compute time. Self time measures wall-clock time as opposed to CPU time and the values are in seconds.',
                                                                 'types': 'The total number of timer types supported.'},
                                                   'values': "Enum('MdgTimerType', {'kTimerType_self': 0, 'kTimerType_inclusive': 1, 'kTimerType_count': 2, 'kTimerTypes': 3})"}},
                        'invertibles': [('setUuid', 'uuid'),
                                        ('setLocked', 'isLocked'),
                                        ('setName', 'name'),
                                        ('setExternalContent',
                                         'getExternalContent'),
                                        ('setIcon', 'icon')],
                        'methods': {'absoluteName': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the absolute name of this node.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The absolute name of this node.',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                    'addAttribute': [{'argInfo': {'attr': {'doc': 'new attribute',
                                                                           'type': 'MObject'}},
                                                      'args': [('attr',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdd a new dynamic attibute to this node.',
                                                      'inArgs': ['attr'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'attr': ['const',
                                                                                  '&']},
                                                      'types': {'attr': 'MObject'}},
                                                     {'argInfo': {'attr': {'doc': 'new attribute ',
                                                                           'type': 'MObject'},
                                                                  'type': {'doc': 'class of attribute to add',
                                                                           'type': ('MFnDependencyNode',
                                                                                    'MAttrClass')}},
                                                      'args': [('attr',
                                                                'MObject',
                                                                'in'),
                                                               ('type',
                                                                ('MFnDependencyNode',
                                                                 'MAttrClass'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': True,
                                                      'doc': '\n This method is obsolete. \n',
                                                      'inArgs': ['attr',
                                                                 'type'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'attr': ['const',
                                                                                  '&'],
                                                                         'type': []},
                                                      'types': {'attr': 'MObject',
                                                                'type': ('MFnDependencyNode',
                                                                         'MAttrClass')}}],
                                    'addExternalContentForFileAttr': [{'argInfo': {'attr': {'doc': 'The attribute for which the plug value will be queried for a location.',
                                                                                            'type': 'MObject'},
                                                                                   'table': {'doc': 'The table in which the new entry will be added. ',
                                                                                             'type': 'MExternalContentInfoTable'}},
                                                                       'args': [('table',
                                                                                 'MExternalContentInfoTable',
                                                                                 'out'),
                                                                                ('attr',
                                                                                 'MObject',
                                                                                 'in')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\r\nAdds content info to the specified table from a file path attribute. \r\n',
                                                                       'inArgs': ['attr'],
                                                                       'outArgs': ['table'],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'attr': ['const',
                                                                                                   '&'],
                                                                                          'table': ['&']},
                                                                       'types': {'attr': 'MObject',
                                                                                 'table': 'MExternalContentInfoTable'}}],
                                    'allocateFlag': [{'argInfo': {'pluginName': {'doc': "The name of the plugin which is allocating the flag. A plugin's name can be retrieved by calling MFnPlugin::name() within its initializePlugin() or uninitializePlugin() functions.",
                                                                                 'type': 'MString'}},
                                                      'args': [('pluginName',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAllocates a node flag for sole use by the caller. Note that the flag is not specific to any one node but is made available to the caller on all nodes. Furthermore, node flags only persist for the duration of the current Maya session: they are not saved with the scene.',
                                                      'inArgs': ['pluginName'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The newly-allocated flag.',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'pluginName': ['const']},
                                                      'types': {'pluginName': 'MString'}}],
                                    'attribute': [{'argInfo': {'index': {'doc': 'the index of the attribute ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nFinds the attribute of this node at the given index. Index order is based on the order in which the attributes were added to the node.',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'A pointer to the attribute',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': ['unsigned']},
                                                   'types': {'index': 'uint'}},
                                                  {'argInfo': {'attrName': {'doc': 'name of the attribute to find ',
                                                                            'type': 'MString'}},
                                                   'args': [('attrName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nFinds the attribute of this node that has the given name.',
                                                   'inArgs': ['attrName'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'A pointer to the attribute',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'attrName': ['const',
                                                                                   '&']},
                                                   'types': {'attrName': 'MString'}}],
                                    'attributeClass': [{'argInfo': {'attribute': {'doc': 'the attribute to check ',
                                                                                  'type': 'MObject'}},
                                                        'args': [('attribute',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the class (normal, dynamic, extension) of the specified attribute.',
                                                        'inArgs': ['attribute'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The class of the attribute. If the node does not have the specified attribute, then kInvalidAttr is returned as the class.',
                                                                       'qualifiers': [],
                                                                       'type': ('MFnDependencyNode',
                                                                                'MAttrClass')},
                                                        'returnType': ('MFnDependencyNode',
                                                                       'MAttrClass'),
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'attribute': ['const',
                                                                                         '&']},
                                                        'types': {'attribute': 'MObject'}}],
                                    'attributeCount': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the number of attributes that this node has.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The attribute count',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                    'canBeWritten': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the do not write state of the node. Will be true if the node can be written/exported to scene files.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'true if the node can be written, false otherwise.',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nClass name. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'classification': [{'argInfo': {'nodeTypeName': {'doc': 'The name of the node for which a classification should be retrieved. Since this is a static method, the typeName method of this class can be used for this parameter if it is desired to get the classification for the attached node.',
                                                                                     'type': 'MString'}},
                                                        'args': [('nodeTypeName',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRetrieves the  classification string  for a node type. This is a string that is used in dependency nodes that are also shaders to provide more detailed  type  information to the rendering system. See the documentation for the MEL commands  getClassification  and  listNodeTypes  for information on the strings that can be provided.',
                                                        'inArgs': ['nodeTypeName'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The classification string. If the node does not have an associated classification, an empty string will be returned. ',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': True,
                                                        'typeQualifiers': {'nodeTypeName': ['const',
                                                                                            '&']},
                                                        'types': {'nodeTypeName': 'MString'}}],
                                    'create': [{'argInfo': {'typeId': {'doc': 'type id of node to be created ',
                                                                       'type': 'MTypeId'}},
                                                'args': [('typeId',
                                                          'MTypeId',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreates a new dependency node with the given type tag. The new node is placed into the dependency graph.',
                                                'inArgs': ['typeId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A pointer to the new dependency node object',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'typeId': ['const',
                                                                              '&']},
                                                'types': {'typeId': 'MTypeId'}},
                                               {'argInfo': {'name': {'doc': 'the name to be assigned to the new node If the node\'s name is not unique, it will be given a unique name by changing its numerical suffix. For example, if this node is called "myNode" and a node by the same name exists, this node will be renamed to "myNode1". ',
                                                                     'type': 'MString'},
                                                            'typeId': {'doc': 'type id of node to be created ',
                                                                       'type': 'MTypeId'}},
                                                'args': [('typeId',
                                                          'MTypeId',
                                                          'in'),
                                                         ('name',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreates a new dependency node with the given type tag. The new node is placed into the dependency graph.',
                                                'inArgs': ['typeId',
                                                           'name'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A pointer to the new dependency node object',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'name': ['const',
                                                                            '&'],
                                                                   'typeId': ['const',
                                                                              '&']},
                                                'types': {'name': 'MString',
                                                          'typeId': 'MTypeId'}},
                                               {'argInfo': {'type': {'doc': 'int name for the type of dependency node ',
                                                                     'type': 'MString'}},
                                                'args': [('type',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreates a new dependency node with the given type. The new node is placed into the dependency graph.',
                                                'inArgs': ['type'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A pointer to the new dependency node object',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'type': ['const',
                                                                            '&']},
                                                'types': {'type': 'MString'}},
                                               {'argInfo': {'name': {'doc': 'the name to be assigned to the new node If the node\'s name is not unique, it will be given a unique name by changing its numerical suffix. For example, if this node is called "myNode" and a node by the same name exists, this node will be renamed to "myNode1". ',
                                                                     'type': 'MString'},
                                                            'type': {'doc': 'int name for the type of dependency node ',
                                                                     'type': 'MString'}},
                                                'args': [('type',
                                                          'MString',
                                                          'in'),
                                                         ('name',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreates a new dependency node with the given type. The new node is placed into the dependency graph.',
                                                'inArgs': ['type',
                                                           'name'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A pointer to the new dependency node object',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'name': ['const',
                                                                            '&'],
                                                                   'type': ['const',
                                                                            '&']},
                                                'types': {'name': 'MString',
                                                          'type': 'MString'}}],
                                    'deallocateAllFlags': [{'argInfo': {'pluginName': {'doc': "The name of the plugin whose flags are to be deallocated. A plugin's name can be retrieved by calling MFnPlugin::name() within its initializePlugin() or uninitializePlugin() functions.",
                                                                                       'type': 'MString'}},
                                                            'args': [('pluginName',
                                                                      'MString',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nDeallocates all of the node flags which are currently allocated to the specified plugin. The deallocated flags immediately become available for use by any plugin.',
                                                            'inArgs': ['pluginName'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': True,
                                                            'typeQualifiers': {'pluginName': ['const']},
                                                            'types': {'pluginName': 'MString'}}],
                                    'deallocateFlag': [{'argInfo': {'flag': {'doc': 'Flag to deallocate.',
                                                                             'type': 'uint'},
                                                                    'pluginName': {'doc': "The name of the plugin which allocated the flag. A plugin's name can be retrieved by calling MFnPlugin::name() within its initializePlugin() or uninitializePlugin() functions.",
                                                                                   'type': 'MString'}},
                                                        'args': [('pluginName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('flag',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nDeallocates a node  flag  which was previously allocated by a call to  allocateFlag . The flag subsequently becomes available for reallocation and use by someone else.',
                                                        'inArgs': ['pluginName',
                                                                   'flag'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'flag': ['unsigned'],
                                                                           'pluginName': ['const']},
                                                        'types': {'flag': 'uint',
                                                                  'pluginName': 'MString'}}],
                                    'dgCallbackIds': [{'argInfo': {'callbackId': {'doc': "Returns an array of callbackIds which were invoked for this node and `callbackName' since the last timer reset. There is a one-to-one correspondence with the `value' array. The entries in the list can include callbackIds that are no longer active (e.g. if you unregistered the callbackId), so be careful not to treat these as active callbackIds -- they are for informational purposes only. ",
                                                                                  'type': 'MCallbackIdArray'},
                                                                   'callbackName': {'doc': 'Name of the callback to query the callbackIds for. This should be one of the callback names that was returned from MFnDependencyNode::dgCallbacks(). ',
                                                                                    'type': 'MString'},
                                                                   'timerType': {'doc': 'The timer we want to query, e.g. kTimerType_self for self time. ',
                                                                                 'type': ('MFnDependencyNode',
                                                                                          'MdgTimerType')},
                                                                   'value': {'doc': "Returns an array of timing values. There is a one-to-one correspondence with the `name' array.",
                                                                             'type': 'MDoubleArray'}},
                                                       'args': [('timerType',
                                                                 ('MFnDependencyNode',
                                                                  'MdgTimerType'),
                                                                 'in'),
                                                                ('callbackName',
                                                                 'MString',
                                                                 'in'),
                                                                ('callbackId',
                                                                 'MCallbackIdArray',
                                                                 'in'),
                                                                ('value',
                                                                 'MDoubleArray',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method provides a further breakdown of the per-callback time returned via  dgCallbacks()  by returning the data on a per-callbackId basis. We define a "callback" to be an event withing Maya that "callback methods" can be registered with to be invoked when the given event occurs. The registered client information is called a "callbackId". There can be multiple callbackIds registered with a given callback, and a callbackId can be shared amongst multiple nodes or multiple callbacks.',
                                                       'inArgs': ['timerType',
                                                                  'callbackName',
                                                                  'callbackId',
                                                                  'value'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'callbackId': ['&'],
                                                                          'callbackName': ['const',
                                                                                           '&'],
                                                                          'timerType': ['const'],
                                                                          'value': ['&']},
                                                       'types': {'callbackId': 'MCallbackIdArray',
                                                                 'callbackName': 'MString',
                                                                 'timerType': ('MFnDependencyNode',
                                                                               'MdgTimerType'),
                                                                 'value': 'MDoubleArray'}}],
                                    'dgCallbacks': [{'argInfo': {'callbackName': {'doc': 'Returns an array of callback names that were invoked for this node since the last timer reset. ',
                                                                                  'type': 'MStringArray'},
                                                                 'timerType': {'doc': 'The timer we want to query, e.g. kTimerType_self for self time. ',
                                                                               'type': ('MFnDependencyNode',
                                                                                        'MdgTimerType')},
                                                                 'value': {'doc': "Returns an array of timing values. There is a one-to-one correspondence with the `callbackName' array.",
                                                                           'type': 'MDoubleArray'}},
                                                     'args': [('timerType',
                                                               ('MFnDependencyNode',
                                                                'MdgTimerType'),
                                                               'in'),
                                                              ('callbackName',
                                                               'MStringArray',
                                                               'in'),
                                                              ('value',
                                                               'MDoubleArray',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nNode callbacks that occur when timing is enabled get logged with the node and can be queried via this method. See the dgCallbackIds method for getting a further breakdown of the time for an individual callback on this node.',
                                                     'inArgs': ['timerType',
                                                                'callbackName',
                                                                'value'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'callbackName': ['&'],
                                                                        'timerType': ['const'],
                                                                        'value': ['&']},
                                                     'types': {'callbackName': 'MStringArray',
                                                               'timerType': ('MFnDependencyNode',
                                                                             'MdgTimerType'),
                                                               'value': 'MDoubleArray'}}],
                                    'dgTimer': [{'argInfo': {'timerMetric': {'doc': 'The timing metric we wish to query. ',
                                                                             'type': ('MFnDependencyNode',
                                                                                      'MdgTimerMetric')},
                                                             'timerType': {'doc': 'The timer type we wish to query. ',
                                                                           'type': ('MFnDependencyNode',
                                                                                    'MdgTimerType')}},
                                                 'args': [('timerMetric',
                                                           ('MFnDependencyNode',
                                                            'MdgTimerMetric'),
                                                           'in'),
                                                          ('timerType',
                                                           ('MFnDependencyNode',
                                                            'MdgTimerType'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThe function returns the specified timer value for the current node. This is the total amount of time spent performing the requested operation since the timer was last reset (see  dgTimerReset()  for details). There are numerous timers per node and these are referenced by the metric and the timer type.',
                                                 'inArgs': ['timerMetric',
                                                            'timerType'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Value of the timer in seconds for types of kTimerType_self and kTimerType_inclusive, and as a simple count for kTimerType_count.',
                                                                'qualifiers': [],
                                                                'type': 'double'},
                                                 'returnType': 'double',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'timerMetric': ['const'],
                                                                    'timerType': ['const']},
                                                 'types': {'timerMetric': ('MFnDependencyNode',
                                                                           'MdgTimerMetric'),
                                                           'timerType': ('MFnDependencyNode',
                                                                         'MdgTimerType')}}],
                                    'dgTimerOff': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nIndicates that this node should no longer collect DG timing data when DG timing is enabled. See  dgTimerOn()  and  enableDGTiming()  for more details.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'dgTimerOn': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nIndicates that this node should collect DG timing data whenever DG timing is enabled. See  enableDGTiming()  for more details.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'dgTimerQueryState': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': "\r\nThe function returns the current on/off state of the node's timer.",
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': "The node's timer's current on/off state.",
                                                                          'qualifiers': [],
                                                                          'type': ('MFnDependencyNode',
                                                                                   'MdgTimerState')},
                                                           'returnType': ('MFnDependencyNode',
                                                                          'MdgTimerState'),
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                    'dgTimerReset': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThe function resets the dependency graph timers and counters for this node to zero. Note that this method does not start or stop timing, it only resets the values to zero. If you want to turn on timing, use the method  dgTimerOn() . If you want to turn off timing, use  dgTimerOff() .',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                    'enableDGTiming': [{'argInfo': {'enable': {'doc': 'flag to turn timing on or off. ',
                                                                               'type': 'bool'}},
                                                        'args': [('enable',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGlobally enables or disables the DG node timing mechanism. There are two levels of control for DG node timing.  dgTimerOn()  and  dgTimerOff()  are used to determine which nodes are eligible for timer data collection and this method is used to globally enable or disable the DG node timing mechanism.',
                                                        'inArgs': ['enable'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'enable': []},
                                                        'types': {'enable': 'bool'}}],
                                    'findAlias': [{'argInfo': {'alias': {'doc': 'alternative name of the attribute ',
                                                                         'type': 'MString'},
                                                               'attrObj': {'doc': 'the attribute having the specified alias ',
                                                                           'type': 'MObject'}},
                                                   'args': [('alias',
                                                             'MString',
                                                             'in'),
                                                            ('attrObj',
                                                             'MObject',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the attribute with the given alias.',
                                                   'inArgs': ['alias'],
                                                   'outArgs': ['attrObj'],
                                                   'returnInfo': {'doc': 'True if the alias was found.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'alias': ['const',
                                                                                '&'],
                                                                      'attrObj': ['&']},
                                                   'types': {'alias': 'MString',
                                                             'attrObj': 'MObject'}}],
                                    'findPlug': [{'argInfo': {'attr': {'doc': 'attribute whose plug we wish to find ',
                                                                       'type': 'MObject'},
                                                              'wantNetworkedPlug': {'doc': 'if true, request a networked plug if it is available ',
                                                                                    'type': 'bool'}},
                                                  'args': [('attr',
                                                            'MObject',
                                                            'in'),
                                                           ('wantNetworkedPlug',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAttempt to find a plug for the given attribute. This method will first try to find the networked version of the plug if requested. The networked version of a plug is one that currently exists in the dependency graph at a particular connection point. If a networked version is not found, then a standard non-networked plug is returned.',
                                                  'inArgs': ['attr',
                                                             'wantNetworkedPlug'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The plug',
                                                                 'qualifiers': [],
                                                                 'type': 'MPlug'},
                                                  'returnType': 'MPlug',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'attr': ['const',
                                                                              '&'],
                                                                     'wantNetworkedPlug': []},
                                                  'types': {'attr': 'MObject',
                                                            'wantNetworkedPlug': 'bool'}},
                                                 {'argInfo': {'attrName': {'doc': 'name of attribute whose plug we wish to find ',
                                                                           'type': 'MString'},
                                                              'wantNetworkedPlug': {'doc': 'if true, request a networked plug if it is available ',
                                                                                    'type': 'bool'}},
                                                  'args': [('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('wantNetworkedPlug',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAttempt to find a plug for the given attribute. This method will first try to find the networked version of the plug if requested. The networked version of a plug is one that currently exists in the dependency graph at a particular connection point. If a networked version is not found, then a standard non-networked plug is returned.',
                                                  'inArgs': ['attrName',
                                                             'wantNetworkedPlug'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The plug',
                                                                 'qualifiers': [],
                                                                 'type': 'MPlug'},
                                                  'returnType': 'MPlug',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'attrName': ['const',
                                                                                  '&'],
                                                                     'wantNetworkedPlug': []},
                                                  'types': {'attrName': 'MString',
                                                            'wantNetworkedPlug': 'bool'}},
                                                 {'argInfo': {'attr': {'doc': 'Attribute to return a plug for. ',
                                                                       'type': 'MObject'}},
                                                  'args': [('attr',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': True,
                                                  'doc': '\n This method is obsolete. \n',
                                                  'inArgs': ['attr'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MPlug'},
                                                  'returnType': 'MPlug',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'attr': ['const',
                                                                              '&']},
                                                  'types': {'attr': 'MObject'}},
                                                 {'argInfo': {'attrName': {'doc': 'Name of attribute to return a plug for. ',
                                                                           'type': 'MString'}},
                                                  'args': [('attrName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': True,
                                                  'doc': '\n This method is obsolete. \n',
                                                  'inArgs': ['attrName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MPlug'},
                                                  'returnType': 'MPlug',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'attrName': ['const',
                                                                                  '&']},
                                                  'types': {'attrName': 'MString'}}],
                                    'getAffectedAttributes': [{'argInfo': {'affectedAttributes': {'doc': 'an array of attributes affected by attr',
                                                                                                  'type': 'MObjectArray'},
                                                                           'attr': {'doc': 'the attribute to check ',
                                                                                    'type': 'MObject'}},
                                                               'args': [('attr',
                                                                         'MObject',
                                                                         'in'),
                                                                        ('affectedAttributes',
                                                                         'MObjectArray',
                                                                         'out')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nReturns an array of attributes that are affected by the attribute passed in. That is, when the given attribute,  attr  is marked dirty (changed) all the  affectedAttributes  attributes will also be marked dirty. For nodes defined in plug-ins this call returns all those attributes that were marked as being affected by the given one via the  MPxNode::attributeAffects  call.',
                                                               'inArgs': ['attr'],
                                                               'outArgs': ['affectedAttributes'],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'affectedAttributes': ['&'],
                                                                                  'attr': ['const',
                                                                                           '&']},
                                                               'types': {'affectedAttributes': 'MObjectArray',
                                                                         'attr': 'MObject'}}],
                                    'getAffectedByAttributes': [{'argInfo': {'affectedByAttributes': {'doc': 'an array of attributes affected by attr',
                                                                                                      'type': 'MObjectArray'},
                                                                             'attr': {'doc': 'the attribute to check ',
                                                                                      'type': 'MObject'}},
                                                                 'args': [('attr',
                                                                           'MObject',
                                                                           'in'),
                                                                          ('affectedByAttributes',
                                                                           'MObjectArray',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nReturns an array of attributes that affect the attribute passed in,  attr . That is, when one of the attributes in  affectedByAttributes  is marked dirty (changed) then  attr  will also be marked dirty. For nodes defined in plug-ins this call returns all those attributes that were marked as affecting the given one via the  MPxNode::attributeAffects  call.',
                                                                 'inArgs': ['attr'],
                                                                 'outArgs': ['affectedByAttributes'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'affectedByAttributes': ['&'],
                                                                                    'attr': ['const',
                                                                                             '&']},
                                                                 'types': {'affectedByAttributes': 'MObjectArray',
                                                                           'attr': 'MObject'}}],
                                    'getAliasAttr': [{'argInfo': {'force': {'doc': 'To indicate whether the alias attr should be created. ',
                                                                            'type': 'bool'}},
                                                      'args': [('force',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nReturns the node's alias attribute, which is a special attribute used to store information about the node's attribute aliases.",
                                                      'inArgs': ['force'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The MObject corresponding to the alias attribute.',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'force': []},
                                                      'types': {'force': 'bool'}}],
                                    'getAliasList': [{'argInfo': {'strArray': {'doc': 'list of aliases ',
                                                                               'type': 'MStringArray'}},
                                                      'args': [('strArray',
                                                                'MStringArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nReturns a list of all attribute aliases for this node. The aliases are pairs of strings with the first being the alias and the second being the attribute's real name.",
                                                      'inArgs': [],
                                                      'outArgs': ['strArray'],
                                                      'returnInfo': {'doc': 'true if any alias was found, false otherwise.',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'strArray': ['&']},
                                                      'types': {'strArray': 'MStringArray'}}],
                                    'getConnections': [{'argInfo': {'array': {'doc': 'storage for the array of plugs',
                                                                              'type': 'MPlugArray'}},
                                                        'args': [('array',
                                                                  'MPlugArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet all of the current connections to this node as an array of plugs.',
                                                        'inArgs': [],
                                                        'outArgs': ['array'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'array': ['&']},
                                                        'types': {'array': 'MPlugArray'}}],
                                    'getExternalContent': [{'argInfo': {'table': {'doc': 'Content information table that this method must populate.',
                                                                                  'type': 'MExternalContentInfoTable'}},
                                                            'args': [('table',
                                                                      'MExternalContentInfoTable',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns the external content (files) that this node depends on. \r\n',
                                                            'inArgs': [],
                                                            'inverse': ('setExternalContent',
                                                                        False),
                                                            'outArgs': ['table'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'table': ['&']},
                                                            'types': {'table': 'MExternalContentInfoTable'}}],
                                    'getPlugsAlias': [{'argInfo': {'aliasName': {'doc': 'alternative name for the attribute ',
                                                                                 'type': 'MString'},
                                                                   'plug': {'doc': 'plug for whose attribute we want the alias ',
                                                                            'type': 'MPlug'}},
                                                       'args': [('plug',
                                                                 'MPlug',
                                                                 'in'),
                                                                ('aliasName',
                                                                 'MString',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                       'inArgs': ['plug'],
                                                       'outArgs': ['aliasName'],
                                                       'returnInfo': {'doc': 'true if the alias was found, false otherwise.',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'aliasName': ['&'],
                                                                          'plug': ['const',
                                                                                   '&']},
                                                       'types': {'aliasName': 'MString',
                                                                 'plug': 'MPlug'}}],
                                    'hasAttribute': [{'argInfo': {'attrName': {'doc': 'Name of attribute to be checked. ',
                                                                               'type': 'MString'}},
                                                      'args': [('attrName',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns true if the node already has an attribute with the given name.',
                                                      'inArgs': ['attrName'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'true if the node has attribute, false otherwise.',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'attrName': ['const',
                                                                                      '&']},
                                                      'types': {'attrName': 'MString'}}],
                                    'hasUniqueName': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': "\r\nIndicates whether or not this node's name is unique within the scene.",
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': "true if the node's name is unique within scene, false otherwise.",
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                    'icon': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the custom icon filename associated with the node. The icon can be assigned using  setIcon() .',
                                              'inArgs': [],
                                              'inverse': ('setIcon',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The custom icon filename, or the empty string (i.e. "") if the node is using Maya\'s default.',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                    'isDefaultNode': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns true if the node is a default node.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'true if the node is default, false otherwise.',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                    'isFlagSet': [{'argInfo': {'flag': {'doc': 'number of the flag to retrieve. ',
                                                                        'type': 'uint'}},
                                                   'args': [('flag',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the current state of the specified  flag  for a node.',
                                                   'inArgs': ['flag'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Current state of the flag',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'flag': ['unsigned']},
                                                   'types': {'flag': 'uint'}}],
                                    'isFromReferencedFile': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': "\r\nIndicates whether or not this node came from a referenced file. If it did, the node will be marked as read-only in the scene and changes to the node's attributes will be saved in the main scene file, not the referenced file from which the node came.",
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'true if the node came from a referenced file, false otherwise.',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                    'isLocked': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nIndicates whether or not this node is locked. See the  setLocked  method for more information on what it means for a node to be locked.',
                                                  'inArgs': [],
                                                  'inverse': ('setLocked',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the node is locked, false otherwise.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'isNewAttribute': [{'argInfo': {'attr': {'doc': 'Attribute to check. ',
                                                                             'type': 'MObject'}},
                                                        'args': [('attr',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nIndicates whether or not the specified attribute was added to this node within the current scene.',
                                                        'inArgs': ['attr'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'true if the attribute was added within the current scene, false if the attribute is permanent or was added within a referenced file.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'attr': ['const',
                                                                                    '&']},
                                                        'types': {'attr': 'MObject'}}],
                                    'isShared': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nIndicates whether or not this node is shared. This comes into play when you attempt to create a new node with the same name as an existing node. If the existing node is shared, then no new node will be created. If the existing node is not shared, then the new node will be created and given a different name.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the node is shared, false otherwise.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'isTrackingEdits': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns whether or not edits on the given node are being tracked by the generalized edit system.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'true if edits on the given node are being tracked, false otherwise.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                    'name': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this node. Note that if the object the instance of this class is attached to is  data  instead of being in the graph (ie. the object was created by one of the MFn*Data function sets, or was passed to an  MPxNode::compute  function in a data block) then the  name  method will not work.',
                                              'inArgs': [],
                                              'inverse': ('setName',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of this node',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                    'parentNamespace': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the name of the namespace in which this node resides. Namespaces are often used when importing files to prevent name collisions.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The name of the namespace in which this node exists. This will be a colon separated path. If the object is in the root namespace, then an empty string will be returned.',
                                                                        'qualifiers': [],
                                                                        'type': 'MString'},
                                                         'returnType': 'MString',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                    'pluginName': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nReturns the name of the plug-in this MFnDependendencyNode was defined in. The name returned is the name of the plug-in on disk, and may contain pathname separators (such as `/') and drive letters (e.g. C:). If this object is not an MFnDependency node, then  MS::kFailure  is returned instead.",
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The name of the plug-in',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                    'plugsAlias': [{'argInfo': {'plug': {'doc': 'plug for whose attribute we want the alias ',
                                                                         'type': 'MPlug'}},
                                                    'args': [('plug',
                                                              'MPlug',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nReturns the alias for the plug's attribute or the empty string if that attribute has no alias.",
                                                    'inArgs': ['plug'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Alternative name for the attribute, if any.',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'plug': ['const',
                                                                                '&']},
                                                    'types': {'plug': 'MPlug'}}],
                                    'removeAttribute': [{'argInfo': {'attribute': {'doc': 'attribute to remove',
                                                                                   'type': 'MObject'}},
                                                         'args': [('attribute',
                                                                   'MObject',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nRemove a dynamic attribute from a node.',
                                                         'inArgs': ['attribute'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'attribute': ['const',
                                                                                          '&']},
                                                         'types': {'attribute': 'MObject'}},
                                                        {'argInfo': {'attribute': {'doc': 'attribute to remove ',
                                                                                   'type': 'MObject'},
                                                                     'type': {'doc': 'class of attribute to remove (must be MFnDependencyNode::kLocalDynamicAttr) See MNodeClass for adding or removing extension attributes.',
                                                                              'type': ('MFnDependencyNode',
                                                                                       'MAttrClass')}},
                                                         'args': [('attribute',
                                                                   'MObject',
                                                                   'in'),
                                                                  ('type',
                                                                   ('MFnDependencyNode',
                                                                    'MAttrClass'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': True,
                                                         'doc': '\n This method is obsolete. \n',
                                                         'inArgs': ['attribute',
                                                                    'type'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'attribute': ['const',
                                                                                          '&'],
                                                                            'type': []},
                                                         'types': {'attribute': 'MObject',
                                                                   'type': ('MFnDependencyNode',
                                                                            'MAttrClass')}}],
                                    'reorderedAttribute': [{'argInfo': {'index': {'doc': 'the reordered index of the attribute ',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSome nodes, such as the various animCurve nodes, require that their attributes be set in a specific order for proper operation. Usually this ordering is only important when the node is being created during file I/O.',
                                                            'inArgs': ['index'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'A pointer to the attribute',
                                                                           'qualifiers': [],
                                                                           'type': 'MObject'},
                                                            'returnType': 'MObject',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'index': ['unsigned']},
                                                            'types': {'index': 'uint'}}],
                                    'setAlias': [{'argInfo': {'add': {'doc': 'true to add the alias, false to remove it ',
                                                                      'type': 'bool'},
                                                              'alias': {'doc': 'alternative name for the attribute ',
                                                                        'type': 'MString'},
                                                              'name': {'doc': 'real name of the attribute ',
                                                                       'type': 'MString'},
                                                              'plug': {'doc': 'plug to the attribute ',
                                                                       'type': 'MPlug'}},
                                                  'args': [('alias',
                                                            'MString',
                                                            'in'),
                                                           ('name',
                                                            'MString',
                                                            'in'),
                                                           ('plug',
                                                            'MPlug',
                                                            'in'),
                                                           ('add',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'add': True},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets or removes an alias (i.e. an alternative name) for an attribute.',
                                                  'inArgs': ['alias',
                                                             'name',
                                                             'plug',
                                                             'add'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'True on success, false on failure. If the ReturnStatus indicates success then false means either that the alias to be added already exists, or the alias to be removed does not exist.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'add': [],
                                                                     'alias': ['const',
                                                                               '&'],
                                                                     'name': ['const',
                                                                              '&'],
                                                                     'plug': ['const',
                                                                              '&']},
                                                  'types': {'add': 'bool',
                                                            'alias': 'MString',
                                                            'name': 'MString',
                                                            'plug': 'MPlug'}}],
                                    'setDoNotWrite': [{'argInfo': {'flag': {'doc': 'True if the node should not be saved. ',
                                                                            'type': 'bool'}},
                                                       'args': [('flag',
                                                                 'bool',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nUse this method to mark the "do not write" state of this node. If set, this node will not be saved when the Maya model is written out.',
                                                       'inArgs': ['flag'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'flag': []},
                                                       'types': {'flag': 'bool'}}],
                                    'setExternalContent': [{'argInfo': {'table': {'doc': 'Key->location table with new content locations.',
                                                                                  'type': 'MExternalContentLocationTable'}},
                                                            'args': [('table',
                                                                      'MExternalContentLocationTable',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nChanges the location of external content. \r\n',
                                                            'inArgs': ['table'],
                                                            'inverse': ('getExternalContent',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'table': ['const',
                                                                                         '&']},
                                                            'types': {'table': 'MExternalContentLocationTable'}}],
                                    'setExternalContentForFileAttr': [{'argInfo': {'attr': {'doc': 'The attribute of the plug we want to write to. ',
                                                                                            'type': 'MObject'},
                                                                                   'table': {'doc': 'A table which may hold or not the value for a given plug.',
                                                                                             'type': 'MExternalContentLocationTable'}},
                                                                       'args': [('attr',
                                                                                 'MObject',
                                                                                 'in'),
                                                                                ('table',
                                                                                 'MExternalContentLocationTable',
                                                                                 'in')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\r\nSets content info in the specified attribute from the table. \r\n',
                                                                       'inArgs': ['attr',
                                                                                  'table'],
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'attr': ['const',
                                                                                                   '&'],
                                                                                          'table': ['const',
                                                                                                    '&']},
                                                                       'types': {'attr': 'MObject',
                                                                                 'table': 'MExternalContentLocationTable'}}],
                                    'setFlag': [{'argInfo': {'flag': {'doc': 'flag to set ',
                                                                      'type': 'uint'},
                                                             'state': {'doc': 'new state to which the flag will be set',
                                                                       'type': 'bool'}},
                                                 'args': [('flag',
                                                           'uint',
                                                           'in'),
                                                          ('state',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the  state  of the specified  flag  for the node.',
                                                 'inArgs': ['flag',
                                                            'state'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'flag': ['unsigned'],
                                                                    'state': []},
                                                 'types': {'flag': 'uint',
                                                           'state': 'bool'}}],
                                    'setIcon': [{'argInfo': {'filename': {'doc': 'specifies the name of the image file defining the icon, or the empty string (i.e. "") to revert to using Maya\'s default. The filename must be a PNG file (.png) and may either be an absolute pathname or be relative to the XBMLANGPATH environment variable.',
                                                                          'type': 'MString'}},
                                                 'args': [('filename',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nAssociates a custom icon with the node for display in the Maya UI. Currently the icon only shows up in Outliner panels (the DAG Outliner, Graph Editor and Dope Sheet).',
                                                 'inArgs': ['filename'],
                                                 'inverse': ('icon',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'filename': ['const',
                                                                                 '&']},
                                                 'types': {'filename': 'MString'}}],
                                    'setLocked': [{'argInfo': {'lock': {'doc': 'If true then node will be locked.',
                                                                        'type': 'bool'}},
                                                   'args': [('lock',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nLocks or unlocks this node.',
                                                   'inArgs': ['lock'],
                                                   'inverse': ('isLocked',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'lock': []},
                                                   'types': {'lock': 'bool'}}],
                                    'setName': [{'argInfo': {'createNamespace': {'doc': 'determine whether or not to create a new namespace when the given name includes a namespace which does not exist. ',
                                                                                 'type': 'bool'},
                                                             'name': {'doc': 'the new name for the node ',
                                                                      'type': 'MString'}},
                                                 'args': [('name',
                                                           'MString',
                                                           'in'),
                                                          ('createNamespace',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {'createNamespace': False},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the name of this node.',
                                                 'inArgs': ['name',
                                                            'createNamespace'],
                                                 'inverse': ('name',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The new name of the node.',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'createNamespace': [],
                                                                    'name': ['const',
                                                                             '&']},
                                                 'types': {'createNamespace': 'bool',
                                                           'name': 'MString'}}],
                                    'setUuid': [{'argInfo': {'muuid': {'doc': 'the new UUID for the node ',
                                                                       'type': 'MUuid'}},
                                                 'args': [('muuid',
                                                           'MUuid',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nSets the node's UUID.",
                                                 'inArgs': ['muuid'],
                                                 'inverse': ('uuid',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'muuid': ['const',
                                                                              '&']},
                                                 'types': {'muuid': 'MUuid'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFunction set type. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'typeId': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the type id of this node. The type is is the 4 byte code that is used in the binary file format to identify the type of this node.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The type id of this node',
                                                               'qualifiers': [],
                                                               'type': 'MTypeId'},
                                                'returnType': 'MTypeId',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                    'typeName': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the type name of this node. The string returned is the name of the node type as it is used in the ascii file format.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The type name of this node',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'userNode': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nIf the function set's node is a plug-in node, then this method will extract the  MPxNode  pointer from it. This method should only be used on node types that are provided by the plug-in calling this method.",
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'A pointer to the user data (NULL if not a plug-in node)',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'MPxNode'},
                                                  'returnType': 'MPxNode',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'uuid': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nReturns the node's UUID.",
                                              'inArgs': [],
                                              'inverse': ('setUuid',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': "The node's UUID.",
                                                             'qualifiers': [],
                                                             'type': 'MUuid'},
                                              'returnType': 'MUuid',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}]},
                        'pymelEnums': {'MAttrClass': "Enum('MAttrClass', [('localDynamicAttr', 1), ('kLocalDynamicAttr', 1), ('normalAttr', 2), ('kNormalAttr', 2), ('extensionAttr', 3), ('kExtensionAttr', 3), ('invalidAttr', 4), ('kInvalidAttr', 4)], multiKeys=True)",
                                       'MdgTimerMetric': "Enum('MdgTimerMetric', [('metric_callback', 0), ('kTimerMetric_callback', 0), ('metric_compute', 1), ('kTimerMetric_compute', 1), ('metric_dirty', 2), ('kTimerMetric_dirty', 2), ('metric_draw', 3), ('kTimerMetric_draw', 3), ('metric_fetch', 4), ('kTimerMetric_fetch', 4), ('metric_callbackViaAPI', 5), ('kTimerMetric_callbackViaAPI', 5), ('metric_callbackNotViaAPI', 6), ('kTimerMetric_callbackNotViaAPI', 6), ('metric_computeDuringCallback', 7), ('kTimerMetric_computeDuringCallback', 7), ('metric_computeNotDuringCallback', 8), ('kTimerMetric_computeNotDuringCallback', 8), ('metrics', 9), ('kTimerMetrics', 9)], multiKeys=True)",
                                       'MdgTimerState': "Enum('MdgTimerState', [('off', 0), ('kTimerOff', 0), ('on', 1), ('kTimerOn', 1), ('uninitialized', 2), ('kTimerUninitialized', 2), ('invalidState', 3), ('kTimerInvalidState', 3)], multiKeys=True)",
                                       'MdgTimerType': "Enum('MdgTimerType', [('type_self', 0), ('kTimerType_self', 0), ('type_inclusive', 1), ('kTimerType_inclusive', 1), ('type_count', 2), ('kTimerType_count', 2), ('types', 3), ('kTimerTypes', 3)], multiKeys=True)"},
                        'pymelMethods': {'icon': 'getIcon',
                                         'name': 'getName',
                                         'uuid': 'getUuid'}},
  'MFnDirectionManip': {'enums': {},
                        'methods': {'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nClass name. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'connectToDirectionPlug': [{'argInfo': {'directionPlug': {'doc': 'the direction plug',
                                                                                              'type': 'MPlug'}},
                                                                'args': [('directionPlug',
                                                                          'MPlug',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nConnect to the direction plug. The data type corresponding to the directionPlug is  MFnNumericData::k3Double .',
                                                                'inArgs': ['directionPlug'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {'directionPlug': ['&']},
                                                                'types': {'directionPlug': 'MPlug'}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nCreates a new DirectionManip. This function set's object is set to be the new manipulator.",
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Newly created DirectionManip',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}},
                                               {'argInfo': {'directionName': {'doc': 'Label for the direction value which appears in the feedback line. ',
                                                                              'type': 'MString'},
                                                            'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                          'type': 'MString'}},
                                                'args': [('manipName',
                                                          'MString',
                                                          'in'),
                                                         ('directionName',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nCreates a new DirectionManip. This function set's object is set to be the new manipulator.",
                                                'inArgs': ['manipName',
                                                           'directionName'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Newly created DirectionManip.',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'directionName': ['const',
                                                                                     '&'],
                                                                   'manipName': ['const',
                                                                                 '&']},
                                                'types': {'directionName': 'MString',
                                                          'manipName': 'MString'}}],
                                    'directionIndex': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the index of the direction. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Direction index',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                    'endPointIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the index of the end point of the DirectionManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'End point index',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                    'setDirection': [{'argInfo': {'direction': {'doc': 'the direction of the DirectionManip',
                                                                                'type': 'MVector'}},
                                                      'args': [('direction',
                                                                'MVector',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the direction of the DirectionManip.',
                                                      'inArgs': ['direction'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'direction': ['&']},
                                                      'types': {'direction': 'MVector'}}],
                                    'setDrawStart': [{'argInfo': {'state': {'doc': 'whether or not the start should be drawn',
                                                                            'type': 'bool'}},
                                                      'args': [('state',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets whether or not to draw the start of the DirectionManip. The start of the DirectionManip is indicated by a grey dot. By default the start is not drawn.',
                                                      'inArgs': ['state'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'state': []},
                                                      'types': {'state': 'bool'}}],
                                    'setNormalizeDirection': [{'argInfo': {'state': {'doc': 'whether or not the direction should be normalized',
                                                                                     'type': 'bool'}},
                                                               'args': [('state',
                                                                         'bool',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nSets whether or not to the direction should be normalized. By default the direction is normalized.',
                                                               'inArgs': ['state'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'state': []},
                                                               'types': {'state': 'bool'}}],
                                    'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the DirectionManip',
                                                                                  'type': 'MPoint'}},
                                                       'args': [('startPoint',
                                                                 'MPoint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the start point of the DirectionManip.',
                                                       'inArgs': ['startPoint'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'startPoint': ['&']},
                                                       'types': {'startPoint': 'MPoint'}}],
                                    'startPointIndex': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the index of the start point of the DirectionManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Start point index',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFunction set type. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFnDirectionalLight': {'enums': {},
                          'invertibles': [('setUseLightPosition',
                                           'useLightPosition'),
                                          ('setShadowAngle', 'shadowAngle')],
                          'methods': {'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nClass name. \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                            'type': 'bool'}},
                                                  'args': [('UIvisible',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'UIvisible': True},
                                                  'deprecated': False,
                                                  'doc': '\nCreates a new directional light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                                  'inArgs': ['UIvisible'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'UIvisible': []},
                                                  'types': {'UIvisible': 'bool'}},
                                                 {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                            'type': 'bool'},
                                                              'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                         'type': 'MObject'},
                                                              'wantTransform': {'doc': "Boolean to indicate whether the transform node is needed or not, which is 'false' by default. ",
                                                                                'type': 'bool'}},
                                                  'args': [('parent',
                                                            'MObject',
                                                            'in'),
                                                           ('UIvisible',
                                                            'bool',
                                                            'in'),
                                                           ('wantTransform',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'UIvisible': True,
                                                               'wantTransform': False},
                                                  'deprecated': False,
                                                  'doc': '\nCreates a new directional light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                                  'inArgs': ['parent',
                                                             'UIvisible',
                                                             'wantTransform'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'UIvisible': [],
                                                                     'parent': ['const',
                                                                                '&'],
                                                                     'wantTransform': []},
                                                  'types': {'UIvisible': 'bool',
                                                            'parent': 'MObject',
                                                            'wantTransform': 'bool'}},
                                                 {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                            'type': 'bool'},
                                                              'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                         'type': 'MObject'}},
                                                  'args': [('parent',
                                                            'MObject',
                                                            'in'),
                                                           ('UIvisible',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'UIvisible': True},
                                                  'deprecated': False,
                                                  'doc': '\nNO SCRIPT SUPPORT. \n',
                                                  'inArgs': ['parent',
                                                             'UIvisible'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'UIvisible': [],
                                                                     'parent': ['const',
                                                                                '&']},
                                                  'types': {'UIvisible': 'bool',
                                                            'parent': 'MObject'}}],
                                      'setShadowAngle': [{'argInfo': {'shadow_angle': {'doc': 'value to which the attribute will be set.',
                                                                                       'type': 'float'}},
                                                          'args': [('shadow_angle',
                                                                    'float',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the value of the "shadowAngle" attribute of a directional light node.',
                                                          'inArgs': ['shadow_angle'],
                                                          'inverse': ('shadowAngle',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'shadow_angle': ['const',
                                                                                              '&']},
                                                          'types': {'shadow_angle': 'float'}}],
                                      'setUseLightPosition': [{'argInfo': {'use_light_position': {'doc': 'value to which the attribute will be set.',
                                                                                                  'type': 'bool'}},
                                                               'args': [('use_light_position',
                                                                         'bool',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nSets the value of the "useLightPosition" attribute of a directional light.',
                                                               'inArgs': ['use_light_position'],
                                                               'inverse': ('useLightPosition',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'use_light_position': ['const']},
                                                               'types': {'use_light_position': 'bool'}}],
                                      'shadowAngle': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nRetrieves the value of the "shadowAngle" attribute of a directional light node. This attribute represents an angular divergence from the direction vector of the light used to calculate soft shadows.',
                                                       'inArgs': [],
                                                       'inverse': ('setShadowAngle',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The value of the "shadowAngle" attribute of the light node.',
                                                                      'qualifiers': [],
                                                                      'type': 'float'},
                                                       'returnType': 'float',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nFunction set type. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                      'useLightPosition': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nRetrieves the value of the "useLightPosition" attribute of a directional light. This attribute determines if the objects behind the light will cast shadows.',
                                                            'inArgs': [],
                                                            'inverse': ('setUseLightPosition',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The value of the "useLightPosition" attribute of the directional light.',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'shadowAngle': 'getShadowAngle',
                                           'useLightPosition': 'getUseLightPosition'}},
  'MFnDiscManip': {'enums': {},
                   'methods': {'angleIndex': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the index of the angle. The data type corresponding to this index is a double.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Angle index',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                               'axisIndex': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the index of the axis of the DiscManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Axis index',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'centerIndex': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the index of the center of the DiscManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Center index',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClass name. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'connectToAnglePlug': [{'argInfo': {'anglePlug': {'doc': 'the angle plug',
                                                                                 'type': 'MPlug'}},
                                                       'args': [('anglePlug',
                                                                 'MPlug',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nConnect to the angle plug. The data type corresponding to the anglePlug is a double. (Note that  MFnUnitAttribute::kAngle  is used to specify an angle attribute.)',
                                                       'inArgs': ['anglePlug'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'anglePlug': ['&']},
                                                       'types': {'anglePlug': 'MPlug'}}],
                               'create': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\r\nCreates a new DiscManip. This function set's object is set to be the new manipulator.",
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Newly created DiscManip',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}},
                                          {'argInfo': {'angleName': {'doc': 'Label for the angle value which appears in the feedback line. ',
                                                                     'type': 'MString'},
                                                       'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                     'type': 'MString'}},
                                           'args': [('manipName',
                                                     'MString',
                                                     'in'),
                                                    ('angleName',
                                                     'MString',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\r\nCreates a new DiscManip. This function set's object is set to be the new manipulator.",
                                           'inArgs': ['manipName',
                                                      'angleName'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Newly created DiscManip.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'angleName': ['const',
                                                                            '&'],
                                                              'manipName': ['const',
                                                                            '&']},
                                           'types': {'angleName': 'MString',
                                                     'manipName': 'MString'}}],
                               'setAngle': [{'argInfo': {'angle': {'doc': 'the angle of the DiscManip',
                                                                   'type': 'MAngle'}},
                                             'args': [('angle',
                                                       'MAngle',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the angle of the DiscManip.',
                                             'inArgs': ['angle'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'angle': []},
                                             'types': {'angle': 'MAngle'}}],
                               'setCenterPoint': [{'argInfo': {'centerPoint': {'doc': 'the center point of the DiscManip',
                                                                               'type': 'MPoint'}},
                                                   'args': [('centerPoint',
                                                             'MPoint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the center point of the DiscManip.',
                                                   'inArgs': ['centerPoint'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'centerPoint': ['const',
                                                                                      '&']},
                                                   'types': {'centerPoint': 'MPoint'}}],
                               'setNormal': [{'argInfo': {'normal': {'doc': 'the normal of the DiscManip',
                                                                     'type': 'MVector'}},
                                              'args': [('normal',
                                                        'MVector',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets the normal of the DiscManip.',
                                              'inArgs': ['normal'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'normal': ['const',
                                                                            '&']},
                                              'types': {'normal': 'MVector'}}],
                               'setRadius': [{'argInfo': {'radius': {'doc': 'the radius of the DiscManip',
                                                                     'type': 'double'}},
                                              'args': [('radius',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets the radius of the DiscManip.',
                                              'inArgs': ['radius'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'radius': []},
                                              'types': {'radius': 'double'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {}},
  'MFnDistanceManip': {'enums': {},
                       'invertibles': [('setScalingFactor',
                                        'scalingFactor')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nClass name. \r\n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'connectToDistancePlug': [{'argInfo': {'distancePlug': {'doc': 'the distance plug',
                                                                                           'type': 'MPlug'}},
                                                              'args': [('distancePlug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nConnect to the distance plug. The data type corresponding to the distancePlug is a double. (Note that  MFnUnitAttribute::kDistance  is used to specify a distance attribute.)',
                                                              'inArgs': ['distancePlug'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'distancePlug': ['&']},
                                                              'types': {'distancePlug': 'MPlug'}}],
                                   'create': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nCreates a new DistanceManip. This function set's object is set to be the new manipulator.",
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Newly created DistanceManip',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}},
                                              {'argInfo': {'distanceName': {'doc': 'Label for the distance value which appears in the feedback line. ',
                                                                            'type': 'MString'},
                                                           'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                         'type': 'MString'}},
                                               'args': [('manipName',
                                                         'MString',
                                                         'in'),
                                                        ('distanceName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nCreates a new DistanceManip. This function set's object is set to be the new manipulator.",
                                               'inArgs': ['manipName',
                                                          'distanceName'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Newly created DistanceManip.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'distanceName': ['const',
                                                                                   '&'],
                                                                  'manipName': ['const',
                                                                                '&']},
                                               'types': {'distanceName': 'MString',
                                                         'manipName': 'MString'}}],
                                   'currentPointIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns the index of the current point of the DistanceManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Current point index',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                   'directionIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the index of the direction. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Direction index',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                   'distanceIndex': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the index of the distance. The data type corresponding to this index is a double.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Distance index',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'isDrawLineOn': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns whether or not a line is being drawn from the start to the end of the DistanceManip. By default the line is drawn.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': ' true the line of the DistanceManip is being drawn  false the line of the DistanceManip is not being drawn  ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'isDrawStartOn': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns whether or not the start of the DistanceManip is being drawn. By default the start is not drawn.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': ' true the start of the DistanceManip is being drawn  false the start of the DistanceManip is not being drawn  ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'scalingFactor': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the scaling factor. The scaling factor is used to determine how int the DistanceManip appears when it is drawn.',
                                                      'inArgs': [],
                                                      'inverse': ('setScalingFactor',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Scaling factor',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'setDirection': [{'argInfo': {'direction': {'doc': 'the direction of the DistanceManip',
                                                                               'type': 'MVector'}},
                                                     'args': [('direction',
                                                               'MVector',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the direction of the DistanceManip.',
                                                     'inArgs': ['direction'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'direction': ['const',
                                                                                      '&']},
                                                     'types': {'direction': 'MVector'}}],
                                   'setDrawLine': [{'argInfo': {'state': {'doc': 'whether or not the line should be drawn',
                                                                          'type': 'bool'}},
                                                    'args': [('state',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets whether or not to draw a line from the start to the end of the DistanceManip. By default the line is drawn.',
                                                    'inArgs': ['state'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'state': []},
                                                    'types': {'state': 'bool'}}],
                                   'setDrawStart': [{'argInfo': {'state': {'doc': 'whether or not the start should be drawn',
                                                                           'type': 'bool'}},
                                                     'args': [('state',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets whether or not to draw the start of the DistanceManip. The start of the DistanceManip is indicated by a grey dot. By default the start is not drawn.',
                                                     'inArgs': ['state'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'state': []},
                                                     'types': {'state': 'bool'}}],
                                   'setScalingFactor': [{'argInfo': {'scalingFactor': {'doc': 'the scaling factor',
                                                                                       'type': 'double'}},
                                                         'args': [('scalingFactor',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the scaling factor. The scaling factor is used to determine how int the DistanceManip appears when it is drawn. The default scaling factor is 1.0.',
                                                         'inArgs': ['scalingFactor'],
                                                         'inverse': ('scalingFactor',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'scalingFactor': []},
                                                         'types': {'scalingFactor': 'double'}}],
                                   'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the DistanceManip',
                                                                                 'type': 'MPoint'}},
                                                      'args': [('startPoint',
                                                                'MPoint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the start point of the DistanceManip.',
                                                      'inArgs': ['startPoint'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'startPoint': ['const',
                                                                                        '&']},
                                                      'types': {'startPoint': 'MPoint'}}],
                                   'startPointIndex': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the index of the start point of the DistanceManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Start point index',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nFunction set type. \r\n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                       'pymelEnums': {},
                       'pymelMethods': {'scalingFactor': 'getScalingFactor'}},
  'MFnDoubleArrayData': {'enums': {},
                         'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the double to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nExtract the indicated double from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return an double containing zero.',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated double ',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}},
                                                     {'argInfo': {'index': {'doc': 'the index of the double to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated double ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                                     'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn an  MDoubleArray  containing the double array currently operated upon by the function set. The  MDoubleArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A copy of the MDoubleArray held in this instance ',
                                                               'qualifiers': [],
                                                               'type': 'MDoubleArray'},
                                                'returnType': 'MDoubleArray',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nClass name. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MDoubleArray to populate',
                                                                      'type': 'MDoubleArray'}},
                                                 'args': [('dest',
                                                           'MDoubleArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCopy all the doubles in the instance into the given  MDoubleArray .',
                                                 'inArgs': [],
                                                 'outArgs': ['dest'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'dest': ['&']},
                                                 'types': {'dest': 'MDoubleArray'}}],
                                     'create': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreate a new double array data object, initialize it to be empty, and attach it to this instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'MObject referring to the newly created double array data object ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                     'type': 'MDoubleArray'}},
                                                 'args': [('arr',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreate a new double array data object, initialize it to contain the data from the given  MDoubleArray , and attach it to this instance.',
                                                 'inArgs': ['arr'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'MObject referring to the newly created double array data object ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MDoubleArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the number of doubles in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of doubles in the instance ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                     'set': [{'argInfo': {'element': {'doc': 'the element to set at the specified index ',
                                                                      'type': 'double'},
                                                          'index': {'doc': 'the index of the double to set',
                                                                    'type': 'uint'}},
                                              'args': [('element',
                                                        'double',
                                                        'in'),
                                                       ('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the double array element at the specified index. The index must be valid for the array.',
                                              'inArgs': ['element',
                                                         'index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'element': [],
                                                                 'index': ['unsigned']},
                                              'types': {'element': 'double',
                                                        'index': 'uint'}},
                                             {'argInfo': {'array': {'doc': 'the MDoubleArray containing the data to set into this instance',
                                                                    'type': 'MDoubleArray'}},
                                              'args': [('array',
                                                        'MDoubleArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the instance to contain the doubles defined in the given  MDoubleArray .',
                                              'inArgs': ['array'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['const',
                                                                           '&']},
                                              'types': {'array': 'MDoubleArray'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFunction set type. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnDoubleIndexedComponent': {'enums': {},
                                'invertibles': [('setCompleteData',
                                                 'getCompleteData')],
                                'methods': {'addElement': [{'argInfo': {'uIndex': {'doc': 'the u index to add ',
                                                                                   'type': 'int'},
                                                                        'vIndex': {'doc': 'the v index to add',
                                                                                   'type': 'int'}},
                                                            'args': [('uIndex',
                                                                      'int',
                                                                      'in'),
                                                                     ('vIndex',
                                                                      'int',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nAdd the specified element to the component.',
                                                            'inArgs': ['uIndex',
                                                                       'vIndex'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'uIndex': [],
                                                                               'vIndex': []},
                                                            'types': {'uIndex': 'int',
                                                                      'vIndex': 'int'}}],
                                            'addElements': [{'argInfo': {'uIndices': {'doc': 'the array of u indices to be added ',
                                                                                      'type': 'MIntArray'},
                                                                         'vIndices': {'doc': 'the array of v indices to be added',
                                                                                      'type': 'MIntArray'}},
                                                             'args': [('uIndices',
                                                                       'MIntArray',
                                                                       'in'),
                                                                      ('vIndices',
                                                                       'MIntArray',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nAdd the specified elements to the component.',
                                                             'inArgs': ['uIndices',
                                                                        'vIndices'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'uIndices': ['const',
                                                                                             '&'],
                                                                                'vIndices': ['const',
                                                                                             '&']},
                                                             'types': {'uIndices': 'MIntArray',
                                                                       'vIndices': 'MIntArray'}}],
                                            'className': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nClass name. \n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'create': [{'argInfo': {'compType': {'doc': 'the type of component to create ',
                                                                                 'type': ('MFn',
                                                                                          'Type')}},
                                                        'args': [('compType',
                                                                  ('MFn',
                                                                   'Type'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nCreate a double indexed component of the given type. Allowable types are',
                                                        'inArgs': ['compType'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The new component',
                                                                       'qualifiers': [],
                                                                       'type': 'MObject'},
                                                        'returnType': 'MObject',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'compType': []},
                                                        'types': {'compType': ('MFn',
                                                                               'Type')}}],
                                            'getCompleteData': [{'argInfo': {'maxU': {'doc': 'storage for the maximum number of U elements ',
                                                                                      'type': 'int'},
                                                                             'maxV': {'doc': 'storage for the maximum number of V elements',
                                                                                      'type': 'int'}},
                                                                 'args': [('maxU',
                                                                           'int',
                                                                           'out'),
                                                                          ('maxV',
                                                                           'int',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nReturns the number of elements for the complete component. A complete component means that all elements are selected.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setCompleteData',
                                                                             False),
                                                                 'outArgs': ['maxU',
                                                                             'maxV'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'maxU': ['&'],
                                                                                    'maxV': ['&']},
                                                                 'types': {'maxU': 'int',
                                                                           'maxV': 'int'}}],
                                            'getElement': [{'argInfo': {'index': {'doc': 'the index of the element to retrieve ',
                                                                                  'type': 'int'},
                                                                        'uIndex': {'doc': 'the u index of the component ',
                                                                                   'type': 'int'},
                                                                        'vIndex': {'doc': 'the v index of the component',
                                                                                   'type': 'int'}},
                                                            'args': [('index',
                                                                      'int',
                                                                      'in'),
                                                                     ('uIndex',
                                                                      'int',
                                                                      'out'),
                                                                     ('vIndex',
                                                                      'int',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nGet the specified element from the component.',
                                                            'inArgs': ['index'],
                                                            'outArgs': ['uIndex',
                                                                        'vIndex'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'index': [],
                                                                               'uIndex': ['&'],
                                                                               'vIndex': ['&']},
                                                            'types': {'index': 'int',
                                                                      'uIndex': 'int',
                                                                      'vIndex': 'int'}}],
                                            'getElements': [{'argInfo': {'uIndices': {'doc': 'storage for the array of u indices ',
                                                                                      'type': 'MIntArray'},
                                                                         'vIndices': {'doc': 'storage for the array of v indices',
                                                                                      'type': 'MIntArray'}},
                                                             'args': [('uIndices',
                                                                       'MIntArray',
                                                                       'out'),
                                                                      ('vIndices',
                                                                       'MIntArray',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nGet all of the element indices from the component.',
                                                             'inArgs': [],
                                                             'outArgs': ['uIndices',
                                                                         'vIndices'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'uIndices': ['&'],
                                                                                'vIndices': ['&']},
                                                             'types': {'uIndices': 'MIntArray',
                                                                       'vIndices': 'MIntArray'}}],
                                            'setCompleteData': [{'argInfo': {'maxU': {'doc': 'the maximum number of U elements ',
                                                                                      'type': 'int'},
                                                                             'maxV': {'doc': 'the maximum number of V elements',
                                                                                      'type': 'int'}},
                                                                 'args': [('maxU',
                                                                           'int',
                                                                           'in'),
                                                                          ('maxV',
                                                                           'int',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nMarks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].',
                                                                 'inArgs': ['maxU',
                                                                            'maxV'],
                                                                 'inverse': ('getCompleteData',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'maxU': [],
                                                                                    'maxV': []},
                                                                 'types': {'maxU': 'int',
                                                                           'maxV': 'int'}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nFunction set type. \n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                                'pymelEnums': {}},
  'MFnDragField': {'enums': {},
                   'invertibles': [('setUseDirection', 'useDirection'),
                                   ('setDirection', 'direction')],
                   'methods': {'direction': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\nReturns the direction of the drag force's influence along the x, y, and z axes. You must have the Use Direction setting turned on for this attribute to take effect.",
                                              'inArgs': [],
                                              'inverse': ('setDirection',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A vector representing direction.',
                                                             'qualifiers': [],
                                                             'type': 'MVector'},
                                              'returnType': 'MVector',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'setDirection': [{'argInfo': {'dragDirection': {'doc': 'A vector representing direction.',
                                                                               'type': 'MVector'}},
                                                 'args': [('dragDirection',
                                                           'MVector',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\nSets the direction of the drag force's influence along the x, y, and z axes. You must have the Use Direction setting turned on for this attribute to take effect.",
                                                 'inArgs': ['dragDirection'],
                                                 'inverse': ('direction',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'dragDirection': ['const',
                                                                                      '&']},
                                                 'types': {'dragDirection': 'MVector'}}],
                               'setUseDirection': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable direction setting.',
                                                                           'type': 'bool'}},
                                                    'args': [('enable',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\nEnables the braking force to be exerted only against the component of the object's velocity that lies along the direction setting of the drag force.",
                                                    'inArgs': ['enable'],
                                                    'inverse': ('useDirection',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'enable': []},
                                                    'types': {'enable': 'bool'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nFunction set type. \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'useDirection': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\nReturns true if the braking force is exerted only against the component of the object's velocity that lies along the direction of the drag force.",
                                                 'inArgs': [],
                                                 'inverse': ('setUseDirection',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true Use the direction setting to determine the braking force.  false Use the objects velocity to determine the braking force.  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'direction': 'getDirection',
                                    'useDirection': 'getUseDirection'}},
  'MFnDynSweptGeometryData': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nClass name. \r\n',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'create': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method create a new swept geometry data object for use with the dependency graph.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A handle to the new swept geometry data object',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                          'lineCount': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturn the number of line segments contained in the data.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Number of line segments ',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                          'sweptLine': [{'argInfo': {'index': {'doc': 'Index of the swept line to return data for. Must be in the range 0 to (lineCount() - 1). ',
                                                                               'type': 'int'}},
                                                         'args': [('index',
                                                                   'int',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturn data for a swept line.',
                                                         'inArgs': ['index'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A const reference to the MDynSweptLine ',
                                                                        'qualifiers': [],
                                                                        'type': 'MDynSweptLine'},
                                                         'returnType': 'MDynSweptLine',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'index': []},
                                                         'types': {'index': 'int'}}],
                                          'sweptTriangle': [{'argInfo': {'index': {'doc': 'Index of the swept triangle to return data for. Must be in the range 0 to (triangleCount() - 1). ',
                                                                                   'type': 'int'}},
                                                             'args': [('index',
                                                                       'int',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturn data for a swept triangle.',
                                                             'inArgs': ['index'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'A const reference to the MDynSweptTriangle ',
                                                                            'qualifiers': [],
                                                                            'type': 'MDynSweptTriangle'},
                                                             'returnType': 'MDynSweptTriangle',
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'index': []},
                                                             'types': {'index': 'int'}}],
                                          'triangleCount': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturn the number of triangles contained in the data.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'Number of triangles ',
                                                                            'qualifiers': [],
                                                                            'type': 'int'},
                                                             'returnType': 'int',
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                                             'types': {}}],
                                          'type': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nFunction set type. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': ('MFn',
                                                                            'Type')},
                                                    'returnType': ('MFn',
                                                                   'Type'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                              'pymelEnums': {}},
  'MFnEnumAttribute': {'enums': {},
                       'invertibles': [('setDefault', 'getDefault')],
                       'methods': {'addField': [{'argInfo': {'fieldString': {'doc': 'The string describing the field ',
                                                                             'type': 'MString'},
                                                             'index': {'doc': 'The index of the field',
                                                                       'type': 'short'}},
                                                 'args': [('fieldString',
                                                           'MString',
                                                           'in'),
                                                          ('index',
                                                           'short',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdd a field (a string/index pair) to the enumeration',
                                                 'inArgs': ['fieldString',
                                                            'index'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'fieldString': ['const',
                                                                                    '&'],
                                                                    'index': []},
                                                 'types': {'fieldString': 'MString',
                                                           'index': 'short'}}],
                                   'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nClass name. \r\n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'create': [{'argInfo': {'briefName': {'doc': 'The brief name of the attribute ',
                                                                         'type': 'MString'},
                                                           'defaultValue': {'doc': 'The default value of the attribute ',
                                                                            'type': 'short'},
                                                           'fullName': {'doc': 'The full name of the attribute ',
                                                                        'type': 'MString'}},
                                               'args': [('fullName',
                                                         'MString',
                                                         'in'),
                                                        ('briefName',
                                                         'MString',
                                                         'in'),
                                                        ('defaultValue',
                                                         'short',
                                                         'in')],
                                               'defaults': {'defaultValue': '0'},
                                               'deprecated': False,
                                               'doc': '\r\nCreates an enumerated attribute object.',
                                               'inArgs': ['fullName',
                                                          'briefName',
                                                          'defaultValue'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The newly created enumerated attribute object.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'briefName': ['const',
                                                                                '&'],
                                                                  'defaultValue': [],
                                                                  'fullName': ['const',
                                                                               '&']},
                                               'types': {'briefName': 'MString',
                                                         'defaultValue': 'short',
                                                         'fullName': 'MString'}}],
                                   'defaultValue': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the default value for the enum attribute.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'the string value for the default enum',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'fieldIndex': [{'argInfo': {'fieldString': {'doc': 'The string describing the field. ',
                                                                               'type': 'MString'}},
                                                   'args': [('fieldString',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieve the index associated with a given string.',
                                                   'inArgs': ['fieldString'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The index associated with the given descriptive string.',
                                                                  'qualifiers': [],
                                                                  'type': 'short'},
                                                   'returnType': 'short',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'fieldString': ['const',
                                                                                      '&']},
                                                   'types': {'fieldString': 'MString'}}],
                                   'fieldName': [{'argInfo': {'index': {'doc': 'The index of the string to look up ',
                                                                        'type': 'short'}},
                                                  'args': [('index',
                                                            'short',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieve the string associated with a given index',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The descriptive string corresponding to the given index',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'index': []},
                                                  'types': {'index': 'short'}}],
                                   'getDefault': [{'argInfo': {'index': {'doc': 'default index value.',
                                                                         'type': 'short'}},
                                                   'args': [('index',
                                                             'short',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the default value for the enum attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setDefault',
                                                               False),
                                                   'outArgs': ['index'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'index': ['&']},
                                                   'types': {'index': 'short'}},
                                                  {'argInfo': {'fieldString': {'doc': 'the string value for the default enum',
                                                                               'type': 'MString'}},
                                                   'args': [('fieldString',
                                                             'MString',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                   'inArgs': [],
                                                   'inverse': ('setDefault',
                                                               False),
                                                   'outArgs': ['fieldString'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'fieldString': ['&']},
                                                   'types': {'fieldString': 'MString'}}],
                                   'getMax': [{'argInfo': {'maxValue': {'doc': 'the maximum value for this attribute',
                                                                        'type': 'short'}},
                                               'args': [('maxValue',
                                                         'short',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the maximum value for this attribute.',
                                               'inArgs': [],
                                               'outArgs': ['maxValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['&']},
                                               'types': {'maxValue': 'short'}}],
                                   'getMin': [{'argInfo': {'minValue': {'doc': 'the minimum value for this attribute',
                                                                        'type': 'short'}},
                                               'args': [('minValue',
                                                         'short',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the minimum value for this attribute.',
                                               'inArgs': [],
                                               'outArgs': ['minValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['&']},
                                               'types': {'minValue': 'short'}}],
                                   'setDefault': [{'argInfo': {'index': {'doc': 'new the default value for this attribute',
                                                                         'type': 'short'}},
                                                   'args': [('index',
                                                             'short',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet a new default value for this enum attribute.',
                                                   'inArgs': ['index'],
                                                   'inverse': ('getDefault',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'index': []},
                                                   'types': {'index': 'short'}},
                                                  {'argInfo': {'fieldString': {'doc': 'new the default value for this attribute',
                                                                               'type': 'MString'}},
                                                   'args': [('fieldString',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet a new default value for this enum attribute.',
                                                   'inArgs': ['fieldString'],
                                                   'inverse': ('getDefault',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'fieldString': ['const',
                                                                                      '&']},
                                                   'types': {'fieldString': 'MString'}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nFunction set type. \r\n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                       'pymelEnums': {}},
  'MFnExpression': {'enums': {'UnitConversion': {'valueDocs': {'all': 'Convert all units.',
                                                               'angularOnly': 'Only convert angular units.',
                                                               'kAll': 'Convert all units.',
                                                               'kAngularOnly': 'Only convert angular units.',
                                                               'kNone': 'Do not do any unit conversion.',
                                                               'none': 'Do not do any unit conversion.'},
                                                 'values': "Enum('UnitConversion', {'kAll': 0, 'kNone': 1, 'kAngularOnly': 2})"}},
                    'invertibles': [('setUnitConversion', 'unitConversion'),
                                    ('setDefaultObject',
                                     'getDefaultObject'),
                                    ('setAnimated', 'isAnimated'),
                                    ('setExpression', 'expression')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nClass name. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {'expression': {'doc': 'The expression string ',
                                                                       'type': 'MString'},
                                                        'object': {'doc': 'The default object (optional - see above) ',
                                                                   'type': 'MObject'}},
                                            'args': [('expression',
                                                      'MString',
                                                      'in'),
                                                     ('object',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {'object': 'MObject::kNullObj'},
                                            'deprecated': False,
                                            'doc': '\nThis method creates and returns a dependency node for a given expression.',
                                            'inArgs': ['expression',
                                                       'object'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The expression node',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'expression': ['const',
                                                                              '&'],
                                                               'object': ['&']},
                                            'types': {'expression': 'MString',
                                                      'object': 'MObject'}}],
                                'evaluate': [{'argInfo': {'result': {'doc': 'the value of the expression',
                                                                     'type': 'MDoubleArray'}},
                                              'args': [('result',
                                                        'MDoubleArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nEvaluate this expression and return the result.',
                                              'inArgs': [],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'result': ['&']},
                                              'types': {'result': 'MDoubleArray'}}],
                                'expression': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nGets the expression string for this expression node.',
                                                'inArgs': [],
                                                'inverse': ('setExpression',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The expression string',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'getDefaultObject': [{'argInfo': {'object': {'doc': 'storage for the default object',
                                                                             'type': 'MObject'}},
                                                      'args': [('object',
                                                                'MObject',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGets the "default" object for the expression. Not all expressions have a default object. If there is no default object for the expression, the object will be set to MObject::kNullObject and the return status will indicate success. This is a completely legal case that the calling code should check for before blindly using the returned object.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefaultObject',
                                                                  False),
                                                      'outArgs': ['object'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'object': ['&']},
                                                      'types': {'object': 'MObject'}}],
                                'getExpression': [{'argInfo': {'expression': {'doc': 'The expression string',
                                                                              'type': 'MString'}},
                                                   'args': [('expression',
                                                             'MString',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nNO SCRIPT SUPPORT. \n',
                                                   'inArgs': [],
                                                   'outArgs': ['expression'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'expression': ['&']},
                                                   'types': {'expression': 'MString'}}],
                                'isAnimated': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nIf this is  true , then the expression will be evaluated whenever time changes, regardless of whether the other inputs have changed.',
                                                'inArgs': [],
                                                'inverse': ('setAnimated',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' true expression will be evaluated whenever time changes  false  ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'setAnimated': [{'argInfo': {'value': {'doc': 'sets the objects evaluation type',
                                                                       'type': 'bool'}},
                                                 'args': [('value',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {'value': False},
                                                 'deprecated': False,
                                                 'doc': '\nSets the way in which the expression is evaluated.',
                                                 'inArgs': ['value'],
                                                 'inverse': ('isAnimated',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'value': []},
                                                 'types': {'value': 'bool'}}],
                                'setDefaultObject': [{'argInfo': {'object': {'doc': 'the object to be set',
                                                                             'type': 'MObject'}},
                                                      'args': [('object',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets the "default" object for the expression. This allows the expression writer to not type the object name for frequently-used objects.',
                                                      'inArgs': ['object'],
                                                      'inverse': ('getDefaultObject',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'object': ['&']},
                                                      'types': {'object': 'MObject'}}],
                                'setExpression': [{'argInfo': {'expression': {'doc': 'The expression string',
                                                                              'type': 'MString'}},
                                                   'args': [('expression',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the expression string for this expression node.',
                                                   'inArgs': ['expression'],
                                                   'inverse': ('expression',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'expression': ['const',
                                                                                     '&']},
                                                   'types': {'expression': 'MString'}}],
                                'setUnitConversion': [{'argInfo': {'conversion': {'doc': 'unit conversion state for this node',
                                                                                  'type': ('MFnExpression',
                                                                                           'UnitConversion')}},
                                                       'args': [('conversion',
                                                                 ('MFnExpression',
                                                                  'UnitConversion'),
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSet the unit conversion options for the expression node.',
                                                       'inArgs': ['conversion'],
                                                       'inverse': ('unitConversion',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'conversion': []},
                                                       'types': {'conversion': ('MFnExpression',
                                                                                'UnitConversion')}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nFunction set type. \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'unitConversion': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet the unit conversion status for the expression node.',
                                                    'inArgs': [],
                                                    'inverse': ('setUnitConversion',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The unit conversion state for this node',
                                                                   'qualifiers': [],
                                                                   'type': ('MFnExpression',
                                                                            'UnitConversion')},
                                                    'returnType': ('MFnExpression',
                                                                   'UnitConversion'),
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}]},
                    'pymelEnums': {'UnitConversion': "Enum('UnitConversion', [('all', 0), ('kAll', 0), ('none', 1), ('kNone', 1), ('angularOnly', 2), ('kAngularOnly', 2)], multiKeys=True)"},
                    'pymelMethods': {'expression': 'getExpression',
                                     'unitConversion': 'getUnitConversion'}},
  'MFnField': {'enums': {},
               'invertibles': [('setAttenuation', 'attenuation'),
                               ('setPerVertex', 'perVertex'),
                               ('setMagnitude', 'magnitude'),
                               ('setMaxDistance', 'maxDistance'),
                               ('setUseMaxDistance', 'useMaxDistance')],
               'methods': {'attenuation': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns the rate of change where the strength of the field changes as the distance between the field and the affected object increases.',
                                            'inArgs': [],
                                            'inverse': ('setAttenuation',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' A positive value representing the exponent for rate of change.  A value of 0 and the force remains constant over distance.  ',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                           'falloffCurve': [{'argInfo': {'param': {'doc': 'Parameter ',
                                                                   'type': 'double'}},
                                             'args': [('param',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns falloff given the param in [0,1]. This is enabled if the use the maximum distance is enabled.',
                                             'inArgs': ['param'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The falloff value given the param.',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'param': ['const']},
                                             'types': {'param': 'double'}}],
                           'getForceAtPoint': [{'argInfo': {'deltaTime': {'doc': 'time increment in seconds for usage with the Air and Vortex fields. Default is (1.0 / 24.0 fps).',
                                                                          'type': 'double'},
                                                            'force': {'doc': 'output array of forces applied to each point. If the length of the force array supplied is 0, the array is automatically resized. If the contents of the force array contains data, the computed force is added to the supplied data. This can be useful to accumulate forces of multiple fields. ',
                                                                      'type': 'MVectorArray'},
                                                            'mass': {'doc': 'array of mass values for each point. If the length of the mass array is 0, a mass of 1.0 is assumed for all the points. ',
                                                                     'type': 'MDoubleArray'},
                                                            'point': {'doc': 'array of positions for each point. ',
                                                                      'type': 'MPointArray'},
                                                            'velocity': {'doc': 'array of velocities for each point. If the length of the velocity array is 0, a velocity of 0.0 is assumed for all the points. Note the velocity array is a requirement for the Air and Drag fields to compute forces. ',
                                                                         'type': 'MVectorArray'}},
                                                'args': [('point',
                                                          'MPointArray',
                                                          'in'),
                                                         ('velocity',
                                                          'MVectorArray',
                                                          'in'),
                                                         ('mass',
                                                          'MDoubleArray',
                                                          'in'),
                                                         ('force',
                                                          'MVectorArray',
                                                          'out'),
                                                         ('deltaTime',
                                                          'double',
                                                          'in')],
                                                'defaults': {'deltaTime': 0.041666666666666664},
                                                'deprecated': False,
                                                'doc': '\nCompute the force of a field on an array of points, given their position, velocity, and mass. Note that only the Air and Vortex fields require a time increment to compute forces, all other fields will ignore this argument.',
                                                'inArgs': ['point',
                                                           'velocity',
                                                           'mass',
                                                           'deltaTime'],
                                                'outArgs': ['force'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'deltaTime': [],
                                                                   'force': ['&'],
                                                                   'mass': ['const',
                                                                            '&'],
                                                                   'point': ['const',
                                                                             '&'],
                                                                   'velocity': ['const',
                                                                                '&']},
                                                'types': {'deltaTime': 'double',
                                                          'force': 'MVectorArray',
                                                          'mass': 'MDoubleArray',
                                                          'point': 'MPointArray',
                                                          'velocity': 'MVectorArray'}},
                                               {'argInfo': {'deltaTime': {'doc': 'time increment in seconds for usage with the Air and Vortex fields. Default is (1.0 / 24.0 fps).',
                                                                          'type': 'double'},
                                                            'force': {'doc': 'output array of forces applied to each point. If the length of the force array supplied is 0, the array is automatically resized. If the contents of the force array contains data, the computed force is added to the supplied data. This can be useful to accumulate forces of multiple fields. ',
                                                                      'type': 'MVectorArray'},
                                                            'mass': {'doc': 'array of mass values for each point. If the length of the mass array is 0, a mass of 1.0 is assumed for all the points. ',
                                                                     'type': 'MDoubleArray'},
                                                            'point': {'doc': 'array of positions for each point. ',
                                                                      'type': 'MVectorArray'},
                                                            'velocity': {'doc': 'array of velocities for each point. If the length of the velocity array is 0, a velocity of 0.0 is assumed for all the points. Note the velocity array is a requirement for the Air and Drag fields to compute forces. ',
                                                                         'type': 'MVectorArray'}},
                                                'args': [('point',
                                                          'MVectorArray',
                                                          'in'),
                                                         ('velocity',
                                                          'MVectorArray',
                                                          'in'),
                                                         ('mass',
                                                          'MDoubleArray',
                                                          'in'),
                                                         ('force',
                                                          'MVectorArray',
                                                          'out'),
                                                         ('deltaTime',
                                                          'double',
                                                          'in')],
                                                'defaults': {'deltaTime': 0.041666666666666664},
                                                'deprecated': False,
                                                'doc': '\nCompute the force of a field on an array of points, given their position, velocity, and mass. Note that only the Air and Vortex fields require a time increment to compute forces, all other fields will igonore this argument.',
                                                'inArgs': ['point',
                                                           'velocity',
                                                           'mass',
                                                           'deltaTime'],
                                                'outArgs': ['force'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'deltaTime': [],
                                                                   'force': ['&'],
                                                                   'mass': ['const',
                                                                            '&'],
                                                                   'point': ['const',
                                                                             '&'],
                                                                   'velocity': ['const',
                                                                                '&']},
                                                'types': {'deltaTime': 'double',
                                                          'force': 'MVectorArray',
                                                          'mass': 'MDoubleArray',
                                                          'point': 'MVectorArray',
                                                          'velocity': 'MVectorArray'}}],
                           'isFalloffCurveConstantOne': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns true if falloffCurve is a constant one (default) or false if not.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'If falloff curve always returns a constant one',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                           'magnitude': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns the strength of the field.',
                                          'inArgs': [],
                                          'inverse': ('setMagnitude',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A value representing the strength of the field.',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                           'maxDistance': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\nReturns the maximum distance from the field at which the force of the field is exerted. The Use Max Distance setting must be turned on for maximum distance to take effect. The maximum distance is scaled by the falloff curve's non-zero range.",
                                            'inArgs': [],
                                            'inverse': ('setMaxDistance',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A value representing distance in internal linear units.',
                                                           'qualifiers': [],
                                                           'type': 'double',
                                                           'unitType': u'linear'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                           'perVertex': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns true if the field exerts its force on each individual point (cv, particle, vertex) equally. Returns false if the force is exerted only from the geometric center of the object or set of points.',
                                          'inArgs': [],
                                          'inverse': ('setPerVertex',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true Force is applied to each individual point.  false Force is applied from the geometric center.  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                           'setAttenuation': [{'argInfo': {'atten': {'doc': 'A positive value representing the exponent for rate of change. A value of 0 and the force remains constant over distance.',
                                                                     'type': 'double'}},
                                               'args': [('atten',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nSets the rate of change where the strength of the field changes as the distance between the field and the affected object increases.',
                                               'inArgs': ['atten'],
                                               'inverse': ('attenuation',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'atten': []},
                                               'types': {'atten': 'double'}}],
                           'setMagnitude': [{'argInfo': {'mag': {'doc': 'A value representing the strength of the field.',
                                                                 'type': 'double'}},
                                             'args': [('mag',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSets the strength of the field.',
                                             'inArgs': ['mag'],
                                             'inverse': ('magnitude',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'mag': []},
                                             'types': {'mag': 'double'}}],
                           'setMaxDistance': [{'argInfo': {'dist': {'doc': 'A value representing distance in internal linear units.',
                                                                    'type': 'double',
                                                                    'unitType': u'linear'}},
                                               'args': [('dist',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nSets the maximum distance from the field at which the force of the field is exerted. The Use Max Distance setting must be turned on for maximum distance to take effect.',
                                               'inArgs': ['dist'],
                                               'inverse': ('maxDistance',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'dist': []},
                                               'types': {'dist': 'double'}}],
                           'setPerVertex': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable individual point forces.',
                                                                    'type': 'bool'}},
                                             'args': [('enable',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nEnables the field to exert its force on each individual point (cv, particle, vertex) equally. Otherwise, the force is exerted only from the geometric center of the object or set of points.',
                                             'inArgs': ['enable'],
                                             'inverse': ('perVertex',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'enable': []},
                                             'types': {'enable': 'bool'}}],
                           'setUseMaxDistance': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable maximum distance.',
                                                                         'type': 'bool'}},
                                                  'args': [('enable',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nEnables the field to use the maximum distance setting to determine the area of influence.',
                                                  'inArgs': ['enable'],
                                                  'inverse': ('useMaxDistance',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'enable': []},
                                                  'types': {'enable': 'bool'}}],
                           'type': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\nFunction set type. \n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': ('MFn',
                                                             'Type')},
                                     'returnType': ('MFn', 'Type'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                           'useMaxDistance': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns true if the field will use the maximum distance setting to determine the area of influence.',
                                               'inArgs': [],
                                               'inverse': ('setUseMaxDistance',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': ' true Field uses the maximum distance setting.  false Field ignores the maximum distance setting.  ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}]},
               'pymelEnums': {},
               'pymelMethods': {'attenuation': 'getAttenuation',
                                'magnitude': 'getMagnitude',
                                'maxDistance': 'getMaxDistance',
                                'perVertex': 'getPerVertex',
                                'useMaxDistance': 'getUseMaxDistance'}},
  'MFnFloatArrayData': {'enums': {},
                        'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the float to extract',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nExtract the indicated float from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return a float containing zero.',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The indicated float ',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the float to extract',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nNO SCRIPT SUPPORT. \n',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The indicated float ',
                                                                    'qualifiers': ['&'],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}}],
                                    'array': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturn an  MFloatArray  containing the float array currently operated upon by the function set. The  MFloatArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A copy of the MFloatArray held in this instance ',
                                                              'qualifiers': [],
                                                              'type': 'MFloatArray'},
                                               'returnType': 'MFloatArray',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nClass name. \n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'copyTo': [{'argInfo': {'dest': {'doc': 'the MFloatArray to populate',
                                                                     'type': 'MFloatArray'}},
                                                'args': [('dest',
                                                          'MFloatArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nCopy all the floats in the instance into the given  MFloatArray .',
                                                'inArgs': [],
                                                'outArgs': ['dest'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'dest': ['&']},
                                                'types': {'dest': 'MFloatArray'}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nCreate a new float array data object, initialize it to be empty, and attach it to this instance.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'MObject referring to the newly created float array data object ',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}},
                                               {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                    'type': 'MFloatArray'}},
                                                'args': [('arr',
                                                          'MFloatArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nCreate a new float array data object, initialize it to contain the data from the given  MDoubleArray , and attach it to this instance.',
                                                'inArgs': ['arr'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'MObject referring to the newly created float array data object ',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'arr': ['const',
                                                                           '&']},
                                                'types': {'arr': 'MFloatArray'}}],
                                    'length': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturn the number of floats in the instance.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of floats in the instance ',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                    'set': [{'argInfo': {'element': {'doc': 'the element to set at the specified index ',
                                                                     'type': 'float'},
                                                         'index': {'doc': 'the index of the float to set',
                                                                   'type': 'uint'}},
                                             'args': [('element',
                                                       'float',
                                                       'in'),
                                                      ('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSet the float array element at the specified index. The index must be valid for the array.',
                                             'inArgs': ['element',
                                                        'index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'element': [],
                                                                'index': ['unsigned']},
                                             'types': {'element': 'float',
                                                       'index': 'uint'}},
                                            {'argInfo': {'array': {'doc': 'the MFloatArray containing the data to set into this instance',
                                                                   'type': 'MFloatArray'}},
                                             'args': [('array',
                                                       'MFloatArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSet the instance to contain the floats defined in the given  MFloatArray .',
                                             'inArgs': ['array'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'array': ['const',
                                                                          '&']},
                                             'types': {'array': 'MFloatArray'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nFunction set type. \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFnFluid': {'enums': {'ColorMethod': {'valueDocs': {'dynamicColorGrid': 'Values in the grid come from a dynamic solver.',
                                                       'kDynamicColorGrid': 'Values in the grid come from a dynamic solver.',
                                                       'kStaticColorGrid': 'Values in the grid are static.',
                                                       'kUseShadingColor': 'Off, use shading color instead.',
                                                       'staticColorGrid': 'Values in the grid are static.',
                                                       'useShadingColor': 'Off, use shading color instead.'},
                                         'values': "Enum('ColorMethod', {'kUseShadingColor': 0, 'kStaticColorGrid': 1, 'kDynamicColorGrid': 2})"},
                         'CoordinateMethod': {'valueDocs': {'fixed': 'Values are equal the object space coordinates.',
                                                            'grid': 'Coordinate values will be moved using the current density solver.',
                                                            'kFixed': 'Values are equal the object space coordinates.',
                                                            'kGrid': 'Coordinate values will be moved using the current density solver.'},
                                              'values': "Enum('CoordinateMethod', {'kFixed': 0, 'kGrid': 1})"},
                         'FalloffMethod': {'valueDocs': {'kNoFalloffGrid': 'No falloff grid should be defined.',
                                                         'kStaticFalloffGrid': 'Values in the falloff grid are static.',
                                                         'noFalloffGrid': 'No falloff grid should be defined.',
                                                         'staticFalloffGrid': 'Values in the falloff grid are static.'},
                                           'values': "Enum('FalloffMethod', {'kNoFalloffGrid': 0, 'kStaticFalloffGrid': 1})"},
                         'FluidGradient': {'valueDocs': {'XGradient': 'Ramp the value from zero to one along the X axis.',
                                                         'YGradient': 'Ramp the value from zero to one along the Y axis.',
                                                         'ZGradient': 'Ramp the value from zero to one along the Z axis.',
                                                         'centerGradient': 'Ramps the value from one at the center to zero at the edges.',
                                                         'constant': 'Value is set to one across the volume.',
                                                         'kCenterGradient': 'Ramps the value from one at the center to zero at the edges.',
                                                         'kConstant': 'Value is set to one across the volume.',
                                                         'kNegXGradient': 'Ramp the value from one to zero along the X axis.',
                                                         'kNegYGradient': 'Ramp the value from one to zero along the Y axis.',
                                                         'kNegZGradient': 'Ramp the value from one to zero along the Z axis.',
                                                         'kXGradient': 'Ramp the value from zero to one along the X axis.',
                                                         'kYGradient': 'Ramp the value from zero to one along the Y axis.',
                                                         'kZGradient': 'Ramp the value from zero to one along the Z axis.',
                                                         'negXGradient': 'Ramp the value from one to zero along the X axis.',
                                                         'negYGradient': 'Ramp the value from one to zero along the Y axis.',
                                                         'negZGradient': 'Ramp the value from one to zero along the Z axis.'},
                                           'values': "Enum('FluidGradient', {'kConstant': 0, 'kXGradient': 1, 'kYGradient': 2, 'kZGradient': 3, 'kNegXGradient': 4, 'kNegYGradient': 5, 'kNegZGradient': 6, 'kCenterGradient': 7})"},
                         'FluidMethod': {'valueDocs': {'dynamicGrid': 'Values in the grid come from a dynamic solver.',
                                                       'gradient': 'Ramps the value based on the gradient setting.',
                                                       'kDynamicGrid': 'Values in the grid come from a dynamic solver.',
                                                       'kGradient': 'Ramps the value based on the gradient setting.',
                                                       'kStaticGrid': 'Values in the grid are static.',
                                                       'kZero': 'All values in grid are zero.',
                                                       'staticGrid': 'Values in the grid are static.',
                                                       'zero': 'All values in grid are zero.'},
                                         'values': "Enum('FluidMethod', {'kZero': 0, 'kStaticGrid': 1, 'kDynamicGrid': 2, 'kGradient': 3})"}},
               'invertibles': [('setTemperatureMode', 'getTemperatureMode'),
                               ('setColorMode', 'getColorMode'),
                               ('setFuelMode', 'getFuelMode'),
                               ('setFalloffMode', 'getFalloffMode'),
                               ('setCoordinateMode', 'getCoordinateMode'),
                               ('setDensityMode', 'getDensityMode'),
                               ('setVelocityMode', 'getVelocityMode')],
               'methods': {'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nClass name. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'create2D': [{'argInfo': {'Xdim': {'doc': 'object space size in the x dimension ',
                                                              'type': 'double'},
                                                     'Xres': {'doc': 'number of fluid grid cells in the x dimension ',
                                                              'type': 'uint'},
                                                     'Ydim': {'doc': 'object space size in the y dimension ',
                                                              'type': 'double'},
                                                     'Yres': {'doc': 'number of fluid grid cells in the y dimension ',
                                                              'type': 'uint'},
                                                     'parent': {'doc': 'specifies what to do with the new fluid object. If a DAG object or NULL is given then a transform will be created for the new fluid shape and placed under the specified (optional)parent. ',
                                                                'type': 'MObject'}},
                                         'args': [('Xres', 'uint', 'in'),
                                                  ('Yres', 'uint', 'in'),
                                                  ('Xdim',
                                                   'double',
                                                   'in'),
                                                  ('Ydim',
                                                   'double',
                                                   'in'),
                                                  ('parent',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parent': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nCreates a fluid object from the specified data and sets this function set to operate on the new fluid object.',
                                         'inArgs': ['Xres',
                                                    'Yres',
                                                    'Xdim',
                                                    'Ydim',
                                                    'parent'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': ' If parent is NULL then the transform for this fluid shape is returned  If parent is a DAG object then the new fluid shape is returned  ',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'Xdim': [],
                                                            'Xres': ['unsigned'],
                                                            'Ydim': [],
                                                            'Yres': ['unsigned'],
                                                            'parent': []},
                                         'types': {'Xdim': 'double',
                                                   'Xres': 'uint',
                                                   'Ydim': 'double',
                                                   'Yres': 'uint',
                                                   'parent': 'MObject'}}],
                           'create3D': [{'argInfo': {'Xdim': {'doc': 'object space size in the x dimension ',
                                                              'type': 'double'},
                                                     'Xres': {'doc': 'number of fluid grid cells in the x dimension ',
                                                              'type': 'uint'},
                                                     'Ydim': {'doc': 'object space size in the y dimension ',
                                                              'type': 'double'},
                                                     'Yres': {'doc': 'number of fluid grid cells in the y dimension ',
                                                              'type': 'uint'},
                                                     'Zdim': {'doc': 'object space size in the z dimension ',
                                                              'type': 'double'},
                                                     'Zres': {'doc': 'number of fluid grid cells in the z dimension ',
                                                              'type': 'uint'},
                                                     'parent': {'doc': 'specifies what to do with the new fluid object. If a DAG object or NULL is given then a transform will be created for the new fluid shape and placed under the specified (optional)parent. ',
                                                                'type': 'MObject'}},
                                         'args': [('Xres', 'uint', 'in'),
                                                  ('Yres', 'uint', 'in'),
                                                  ('Zres', 'uint', 'in'),
                                                  ('Xdim',
                                                   'double',
                                                   'in'),
                                                  ('Ydim',
                                                   'double',
                                                   'in'),
                                                  ('Zdim',
                                                   'double',
                                                   'in'),
                                                  ('parent',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parent': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nCreates a fluid object from the specified data and sets this function set to operate on the new fluid object.',
                                         'inArgs': ['Xres',
                                                    'Yres',
                                                    'Zres',
                                                    'Xdim',
                                                    'Ydim',
                                                    'Zdim',
                                                    'parent'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': ' If parent is NULL then the transform for this fluid shape is returned  If parent is a DAG object then the new fluid shape is returned  ',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'Xdim': [],
                                                            'Xres': ['unsigned'],
                                                            'Ydim': [],
                                                            'Yres': ['unsigned'],
                                                            'Zdim': [],
                                                            'Zres': ['unsigned'],
                                                            'parent': []},
                                         'types': {'Xdim': 'double',
                                                   'Xres': 'uint',
                                                   'Ydim': 'double',
                                                   'Yres': 'uint',
                                                   'Zdim': 'double',
                                                   'Zres': 'uint',
                                                   'parent': 'MObject'}}],
                           'density': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThis method returns a pointer to the storage for the density data in the fluid. The size of this array can be obtained using the "gridSize" call.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'Pointer to the density data of the grid',
                                                       'qualifiers': ['*'],
                                                       'type': 'float'},
                                        'returnType': 'float',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                           'emitIntoArrays': [{'argInfo': {'density': {'doc': 'amount of density to add to the voxel ',
                                                                       'type': 'float'},
                                                           'doColor': {'doc': 'if true, then color specified by "emitColor" will be blended into the voxel\'s current color, with the blend coefficients being determined by the amount of density that is being added to the voxel. ',
                                                                       'type': 'bool'},
                                                           'emitColor': {'doc': 'color to be blended into the voxel. ',
                                                                         'type': 'MColor'},
                                                           'fuel': {'doc': 'amount of fuel to add to the voxel ',
                                                                    'type': 'float'},
                                                           'heat': {'doc': 'amount of heat to add to the voxel ',
                                                                    'type': 'float'},
                                                           'val': {'doc': 'multiplier applied to the specified density, heat, and fuel values. ',
                                                                   'type': 'float'},
                                                           'x': {'doc': 'voxel index in x ',
                                                                 'type': 'int'},
                                                           'y': {'doc': 'voxel index in y ',
                                                                 'type': 'int'},
                                                           'z': {'doc': 'voxel index in z ',
                                                                 'type': 'int'}},
                                               'args': [('val',
                                                         'float',
                                                         'in'),
                                                        ('x',
                                                         'int',
                                                         'in'),
                                                        ('y',
                                                         'int',
                                                         'in'),
                                                        ('z',
                                                         'int',
                                                         'in'),
                                                        ('density',
                                                         'float',
                                                         'in'),
                                                        ('heat',
                                                         'float',
                                                         'in'),
                                                        ('fuel',
                                                         'float',
                                                         'in'),
                                                        ('doColor',
                                                         'bool',
                                                         'in'),
                                                        ('emitColor',
                                                         'MColor',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nUse this method to add density, heat, fuel, and/or color to a particular voxel of a fluid.',
                                               'inArgs': ['val',
                                                          'x',
                                                          'y',
                                                          'z',
                                                          'density',
                                                          'heat',
                                                          'fuel',
                                                          'doColor',
                                                          'emitColor'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'density': [],
                                                                  'doColor': [],
                                                                  'emitColor': ['const',
                                                                                '&'],
                                                                  'fuel': [],
                                                                  'heat': [],
                                                                  'val': [],
                                                                  'x': [],
                                                                  'y': [],
                                                                  'z': []},
                                               'types': {'density': 'float',
                                                         'doColor': 'bool',
                                                         'emitColor': 'MColor',
                                                         'fuel': 'float',
                                                         'heat': 'float',
                                                         'val': 'float',
                                                         'x': 'int',
                                                         'y': 'int',
                                                         'z': 'int'}}],
                           'expandToInclude': [{'argInfo': {'max': {'doc': 'point at upper corner of boinding box',
                                                                    'type': 'MPoint'},
                                                            'min': {'doc': 'point at lower corner of bounding box ',
                                                                    'type': 'MPoint'}},
                                                'args': [('min',
                                                          'MPoint',
                                                          'in'),
                                                         ('max',
                                                          'MPoint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nTells the fluid shape to autoresize to include these two points This would normally be used in a fluid emitter node if the fluid had resizeToEmitter turned on. This may fail if the fluid is not autoRise and resizeToEmitter, or if the fluid has reached its maxResolution',
                                                'inArgs': ['min', 'max'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'max': ['const',
                                                                           '&'],
                                                                   'min': ['const',
                                                                           '&']},
                                                'types': {'max': 'MPoint',
                                                          'min': 'MPoint'}}],
                           'falloff': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThis method returns a pointer to the storage for the falloff data in the fluid. The size of this array can be obtained using the "gridSize" call.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'Pointer to the float data of the grid',
                                                       'qualifiers': ['*'],
                                                       'type': 'float'},
                                        'returnType': 'float',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                           'fuel': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nThis method returns a pointer to the storage for the fuel data in the fluid. The size of this array can be obtained using the "gridSize" call.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Pointer to the fuel data of the grid',
                                                    'qualifiers': ['*'],
                                                    'type': 'float'},
                                     'returnType': 'float',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}}],
                           'getColorMode': [{'argInfo': {'method': {'doc': 'storage for returning the method by which the fluid color in the grid is determined',
                                                                    'type': ('MFnFluid',
                                                                             'ColorMethod')}},
                                             'args': [('method',
                                                       ('MFnFluid',
                                                        'ColorMethod'),
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the modes by which the color values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                             'inArgs': [],
                                             'inverse': ('setColorMode',
                                                         False),
                                             'outArgs': ['method'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'method': ['&']},
                                             'types': {'method': ('MFnFluid',
                                                                  'ColorMethod')}}],
                           'getColors': [{'argInfo': {'b': {'doc': 'storage for returning a pointer to the blue components of the color values in the grid',
                                                            'type': 'float'},
                                                      'g': {'doc': 'storage for returning a pointer to the green components of the color values in the grid ',
                                                            'type': 'float'},
                                                      'r': {'doc': 'storage for returning a pointer to the red components of the color values in the grid ',
                                                            'type': 'float'}},
                                          'args': [('r', 'float', 'out'),
                                                   ('g', 'float', 'out'),
                                                   ('b', 'float', 'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThis method returns pointers to the storage for the color data in the fluid. The size of these arrays can be obtained using the "gridSize" call.',
                                          'inArgs': [],
                                          'outArgs': ['r', 'g', 'b'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'b': ['*&'],
                                                             'g': ['*&'],
                                                             'r': ['*&']},
                                          'types': {'b': 'float',
                                                    'g': 'float',
                                                    'r': 'float'}}],
                           'getCoordinateMode': [{'argInfo': {'method': {'doc': 'storage for returning the method by which the fluid coordinate values in the grid is determined',
                                                                         'type': ('MFnFluid',
                                                                                  'CoordinateMethod')}},
                                                  'args': [('method',
                                                            ('MFnFluid',
                                                             'CoordinateMethod'),
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the modes by which the UVW coordinates values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                                  'inArgs': [],
                                                  'inverse': ('setCoordinateMode',
                                                              False),
                                                  'outArgs': ['method'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'method': ['&']},
                                                  'types': {'method': ('MFnFluid',
                                                                       'CoordinateMethod')}}],
                           'getCoordinates': [{'argInfo': {'u': {'doc': 'storage for returning a pointer to the u values in the grid ',
                                                                 'type': 'float'},
                                                           'v': {'doc': 'storage for returning a pointer to the v values in the grid ',
                                                                 'type': 'float'},
                                                           'w': {'doc': 'storage for returning a pointer to the w values in the grid',
                                                                 'type': 'float'}},
                                               'args': [('u',
                                                         'float',
                                                         'out'),
                                                        ('v',
                                                         'float',
                                                         'out'),
                                                        ('w',
                                                         'float',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method returns pointers to the storage for the uvw coordinate data in the fluid. The size of these arrays can be obtained using the "gridSize" call. The uvw values supply the 3D texture mapping coordinates for each cell.',
                                               'inArgs': [],
                                               'outArgs': ['u', 'v', 'w'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'u': ['*&'],
                                                                  'v': ['*&'],
                                                                  'w': ['*&']},
                                               'types': {'u': 'float',
                                                         'v': 'float',
                                                         'w': 'float'}}],
                           'getDensityMode': [{'argInfo': {'gradient': {'doc': 'storage for returning the gradient type, which is only relevant if the method is kGradient',
                                                                        'type': ('MFnFluid',
                                                                                 'FluidGradient')},
                                                           'method': {'doc': 'storage for returning the method by which the fluid density in the grid is determined ',
                                                                      'type': ('MFnFluid',
                                                                               'FluidMethod')}},
                                               'args': [('method',
                                                         ('MFnFluid',
                                                          'FluidMethod'),
                                                         'out'),
                                                        ('gradient',
                                                         ('MFnFluid',
                                                          'FluidGradient'),
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the modes by which the density values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                               'inArgs': [],
                                               'inverse': ('setDensityMode',
                                                           False),
                                               'outArgs': ['method',
                                                           'gradient'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'gradient': ['&'],
                                                                  'method': ['&']},
                                               'types': {'gradient': ('MFnFluid',
                                                                      'FluidGradient'),
                                                         'method': ('MFnFluid',
                                                                    'FluidMethod')}}],
                           'getDimensions': [{'argInfo': {'Xdim': {'doc': 'storage for returning the dimension of the fluid in x ',
                                                                   'type': 'double'},
                                                          'Ydim': {'doc': 'storage for returning the dimension of the fluid in y ',
                                                                   'type': 'double'},
                                                          'Zdim': {'doc': 'storage for returning the dimension of the fluid in z',
                                                                   'type': 'double'}},
                                              'args': [('Xdim',
                                                        'double',
                                                        'out'),
                                                       ('Ydim',
                                                        'double',
                                                        'out'),
                                                       ('Zdim',
                                                        'double',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGets the dimensions of the fluid. The dimensions give the object space size of the fluid object in each direction.',
                                              'inArgs': [],
                                              'outArgs': ['Xdim',
                                                          'Ydim',
                                                          'Zdim'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'Xdim': ['&'],
                                                                 'Ydim': ['&'],
                                                                 'Zdim': ['&']},
                                              'types': {'Xdim': 'double',
                                                        'Ydim': 'double',
                                                        'Zdim': 'double'}}],
                           'getFalloffMode': [{'argInfo': {'method': {'doc': 'storage for returning the method by which the falloff value in the grid is determined',
                                                                      'type': ('MFnFluid',
                                                                               'FalloffMethod')}},
                                               'args': [('method',
                                                         ('MFnFluid',
                                                          'FalloffMethod'),
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the modes by which the falloff values in the grid are determined. If the falloff grid is enabled, its values must be set by the user.',
                                               'inArgs': [],
                                               'inverse': ('setFalloffMode',
                                                           False),
                                               'outArgs': ['method'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'method': ['&']},
                                               'types': {'method': ('MFnFluid',
                                                                    'FalloffMethod')}}],
                           'getForceAtPoint': [{'argInfo': {'deltaTime': {'doc': 'time increment in seconds. Default is (1.0 / 24.0 fps).',
                                                                          'type': 'double'},
                                                            'force': {'doc': 'output array of forces applied to each point. If the length of the force array supplied is 0, the array is automatically resized. If the contents of the force array contains data, the computed force is added to the supplied data. This can be useful to accumulate forces of multiple fields. ',
                                                                      'type': 'MVectorArray'},
                                                            'mass': {'doc': 'array of mass values for each point. If the length of the mass array is 0, a mass of 1.0 is assumed for all the points. ',
                                                                     'type': 'MDoubleArray'},
                                                            'point': {'doc': 'array of positions for each point. ',
                                                                      'type': 'MPointArray'},
                                                            'velocity': {'doc': 'array of velocities for each point. If the length of the velocity array is 0, a velocity of 0.0 is assumed for all the points. ',
                                                                         'type': 'MVectorArray'}},
                                                'args': [('point',
                                                          'MPointArray',
                                                          'in'),
                                                         ('velocity',
                                                          'MVectorArray',
                                                          'in'),
                                                         ('mass',
                                                          'MDoubleArray',
                                                          'in'),
                                                         ('force',
                                                          'MVectorArray',
                                                          'out'),
                                                         ('deltaTime',
                                                          'double',
                                                          'in')],
                                                'defaults': {'deltaTime': 0.041666666666666664},
                                                'deprecated': False,
                                                'doc': '\r\nCompute the force of the fluid as a field on an array of points, given their position, velocity, and mass.',
                                                'inArgs': ['point',
                                                           'velocity',
                                                           'mass',
                                                           'deltaTime'],
                                                'outArgs': ['force'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'deltaTime': [],
                                                                   'force': ['&'],
                                                                   'mass': ['const',
                                                                            '&'],
                                                                   'point': ['const',
                                                                             '&'],
                                                                   'velocity': ['const',
                                                                                '&']},
                                                'types': {'deltaTime': 'double',
                                                          'force': 'MVectorArray',
                                                          'mass': 'MDoubleArray',
                                                          'point': 'MPointArray',
                                                          'velocity': 'MVectorArray'}},
                                               {'argInfo': {'deltaTime': {'doc': 'time increment in seconds for usage with the Air and Vortex fields. Default is (1.0 / 24.0 fps).',
                                                                          'type': 'double'},
                                                            'force': {'doc': 'output array of forces applied to each point. If the length of the force array supplied is 0, the array is automatically resized. If the contents of the force array contains data, the computed force is added to the supplied data. This can be useful to accumulate forces of multiple fields. ',
                                                                      'type': 'MVectorArray'},
                                                            'mass': {'doc': 'array of mass values for each point. If the length of the mass array is 0, a mass of 1.0 is assumed for all the points. ',
                                                                     'type': 'MDoubleArray'},
                                                            'point': {'doc': 'array of positions for each point. ',
                                                                      'type': 'MVectorArray'},
                                                            'velocity': {'doc': 'array of velocities for each point. If the length of the velocity array is 0, a velocity of 0.0 is assumed for all the points. Note the velocity array is a requirement for the Air and Drag fields to compute forces. ',
                                                                         'type': 'MVectorArray'}},
                                                'args': [('point',
                                                          'MVectorArray',
                                                          'in'),
                                                         ('velocity',
                                                          'MVectorArray',
                                                          'in'),
                                                         ('mass',
                                                          'MDoubleArray',
                                                          'in'),
                                                         ('force',
                                                          'MVectorArray',
                                                          'out'),
                                                         ('deltaTime',
                                                          'double',
                                                          'in')],
                                                'defaults': {'deltaTime': 0.041666666666666664},
                                                'deprecated': False,
                                                'doc': '\r\nCompute the force of a field on an array of points, given their position, velocity, and mass. Note that only the Air and Vortex fields require a time increment to compute forces, all other fields will igonore this argument.',
                                                'inArgs': ['point',
                                                           'velocity',
                                                           'mass',
                                                           'deltaTime'],
                                                'outArgs': ['force'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'deltaTime': [],
                                                                   'force': ['&'],
                                                                   'mass': ['const',
                                                                            '&'],
                                                                   'point': ['const',
                                                                             '&'],
                                                                   'velocity': ['const',
                                                                                '&']},
                                                'types': {'deltaTime': 'double',
                                                          'force': 'MVectorArray',
                                                          'mass': 'MDoubleArray',
                                                          'point': 'MVectorArray',
                                                          'velocity': 'MVectorArray'}}],
                           'getFuelMode': [{'argInfo': {'gradient': {'doc': 'storage for returning the gradient type, which is only relevant if the method is kGradient',
                                                                     'type': ('MFnFluid',
                                                                              'FluidGradient')},
                                                        'method': {'doc': 'storage for returning the method by which the fluid fuel values in the grid is determined ',
                                                                   'type': ('MFnFluid',
                                                                            'FluidMethod')}},
                                            'args': [('method',
                                                      ('MFnFluid',
                                                       'FluidMethod'),
                                                      'out'),
                                                     ('gradient',
                                                      ('MFnFluid',
                                                       'FluidGradient'),
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGet the modes by which the fuel values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                            'inArgs': [],
                                            'inverse': ('setFuelMode',
                                                        False),
                                            'outArgs': ['method',
                                                        'gradient'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'gradient': ['&'],
                                                               'method': ['&']},
                                            'types': {'gradient': ('MFnFluid',
                                                                   'FluidGradient'),
                                                      'method': ('MFnFluid',
                                                                 'FluidMethod')}}],
                           'getResolution': [{'argInfo': {'Xres': {'doc': 'storage for returning the number of fluid grid cells in the x dimension ',
                                                                   'type': 'uint'},
                                                          'Yres': {'doc': 'storage for returning the number of fluid grid cells in the y dimension ',
                                                                   'type': 'uint'},
                                                          'Zres': {'doc': 'storage for returning the number of fluid grid cells in the z dimension',
                                                                   'type': 'uint'}},
                                              'args': [('Xres',
                                                        'uint',
                                                        'out'),
                                                       ('Yres',
                                                        'uint',
                                                        'out'),
                                                       ('Zres',
                                                        'uint',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGets the resolution of the fluid. The resolution gives the number of cells in the fluid grid in each direction.',
                                              'inArgs': [],
                                              'outArgs': ['Xres',
                                                          'Yres',
                                                          'Zres'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'Xres': ['unsigned',
                                                                          '&'],
                                                                 'Yres': ['unsigned',
                                                                          '&'],
                                                                 'Zres': ['unsigned',
                                                                          '&']},
                                              'types': {'Xres': 'uint',
                                                        'Yres': 'uint',
                                                        'Zres': 'uint'}},
                                             {'argInfo': {'Xres': {'doc': 'storage for returning the number of fluid grid cells in the x dimension ',
                                                                   'type': 'uint'},
                                                          'Yres': {'doc': 'storage for returning the number of fluid grid cells in the y dimension',
                                                                   'type': 'uint'}},
                                              'args': [('Xres',
                                                        'uint',
                                                        'out'),
                                                       ('Yres',
                                                        'uint',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGets the resolution of the fluid. The resolution gives the number of cells in the fluid grid in each direction.',
                                              'inArgs': [],
                                              'outArgs': ['Xres', 'Yres'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'Xres': ['unsigned',
                                                                          '&'],
                                                                 'Yres': ['unsigned',
                                                                          '&']},
                                              'types': {'Xres': 'uint',
                                                        'Yres': 'uint'}}],
                           'getTemperatureMode': [{'argInfo': {'gradient': {'doc': 'storage for returning the gradient type, which is only relevant if the method is kGradient',
                                                                            'type': ('MFnFluid',
                                                                                     'FluidGradient')},
                                                               'method': {'doc': 'storage for returning the method by which the fluid temperature in the grid is determined ',
                                                                          'type': ('MFnFluid',
                                                                                   'FluidMethod')}},
                                                   'args': [('method',
                                                             ('MFnFluid',
                                                              'FluidMethod'),
                                                             'out'),
                                                            ('gradient',
                                                             ('MFnFluid',
                                                              'FluidGradient'),
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the modes by which the temperature values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                                   'inArgs': [],
                                                   'inverse': ('setTemperatureMode',
                                                               False),
                                                   'outArgs': ['method',
                                                               'gradient'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'gradient': ['&'],
                                                                      'method': ['&']},
                                                   'types': {'gradient': ('MFnFluid',
                                                                          'FluidGradient'),
                                                             'method': ('MFnFluid',
                                                                        'FluidMethod')}}],
                           'getVelocity': [{'argInfo': {'Xvel': {'doc': 'storage for returning a pointer to the x components of the velocity values in the grid ',
                                                                 'type': 'float'},
                                                        'Yvel': {'doc': 'storage for returning a pointer to the y components of the velocity values in the grid ',
                                                                 'type': 'float'},
                                                        'Zvel': {'doc': 'storage for returning a pointer to the z components of the velocity values in the grid',
                                                                 'type': 'float'}},
                                            'args': [('Xvel',
                                                      'float',
                                                      'out'),
                                                     ('Yvel',
                                                      'float',
                                                      'out'),
                                                     ('Zvel',
                                                      'float',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method returns pointers to the storage for the velocity data in the fluid. The size of these arrays can be obtained using the "velocityGridSizes" call.',
                                            'inArgs': [],
                                            'outArgs': ['Xvel',
                                                        'Yvel',
                                                        'Zvel'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'Xvel': ['*&'],
                                                               'Yvel': ['*&'],
                                                               'Zvel': ['*&']},
                                            'types': {'Xvel': 'float',
                                                      'Yvel': 'float',
                                                      'Zvel': 'float'}}],
                           'getVelocityMode': [{'argInfo': {'gradient': {'doc': 'storage for returning the gradient type, which is only relevant if the method is kGradient',
                                                                         'type': ('MFnFluid',
                                                                                  'FluidGradient')},
                                                            'method': {'doc': 'storage for returning the method by which the fluid velocity in the grid is determined ',
                                                                       'type': ('MFnFluid',
                                                                                'FluidMethod')}},
                                                'args': [('method',
                                                          ('MFnFluid',
                                                           'FluidMethod'),
                                                          'out'),
                                                         ('gradient',
                                                          ('MFnFluid',
                                                           'FluidGradient'),
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the modes by which the velocity values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                                'inArgs': [],
                                                'inverse': ('setVelocityMode',
                                                            False),
                                                'outArgs': ['method',
                                                            'gradient'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'gradient': ['&'],
                                                                   'method': ['&']},
                                                'types': {'gradient': ('MFnFluid',
                                                                       'FluidGradient'),
                                                          'method': ('MFnFluid',
                                                                     'FluidMethod')}}],
                           'gridSize': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the number of elements in the grid. This is equal to (x resolution * y resolution * z resolution). This routine is provided as a convenience to be used with the methods that give direct access to the fluid data. This gives the upper bound on the arrays. This size applies to all grids except for the 3 velocity grids.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of elements.',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                           'index': [{'argInfo': {'xi': {'doc': 'index in x ',
                                                         'type': 'int'},
                                                  'yi': {'doc': 'index in y',
                                                         'type': 'int'}},
                                      'args': [('xi', 'int', 'in'),
                                               ('yi', 'int', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nThis is a utility routine for finding the index of a cell in an array of fluid data. The data in the fluid shape, such as color and density are passed back as single dimensional arrays of numeric values. This method converts three dimensional coordinates of a cell into the index value that refers the cell's value in the single dimensional array.",
                                      'inArgs': ['xi', 'yi'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Index in the single dimensional array ',
                                                     'qualifiers': [],
                                                     'type': 'int'},
                                      'returnType': 'int',
                                      'static': False,
                                      'typeQualifiers': {'xi': [],
                                                         'yi': []},
                                      'types': {'xi': 'int', 'yi': 'int'}},
                                     {'argInfo': {'xi': {'doc': 'index in x ',
                                                         'type': 'int'},
                                                  'yi': {'doc': 'index in y ',
                                                         'type': 'int'},
                                                  'zi': {'doc': 'index in z',
                                                         'type': 'int'}},
                                      'args': [('xi', 'int', 'in'),
                                               ('yi', 'int', 'in'),
                                               ('zi', 'int', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nThis is a utility routine for finding the index of a cell in an array of fluid data. The data in the fluid shape, such as color and density are passed back as single dimensional arrays of numeric values. This method converts three dimensional coordinates of a cell into the index value that refers the cell's value in the single dimensional array.",
                                      'inArgs': ['xi', 'yi', 'zi'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Index in the single dimensional array ',
                                                     'qualifiers': [],
                                                     'type': 'int'},
                                      'returnType': 'int',
                                      'static': False,
                                      'typeQualifiers': {'xi': [],
                                                         'yi': [],
                                                         'zi': []},
                                      'types': {'xi': 'int',
                                                'yi': 'int',
                                                'zi': 'int'}},
                                     {'argInfo': {'index': {'doc': 'index to convert into coordinates ',
                                                            'type': 'int'},
                                                  'xi': {'doc': 'storage for the index in x ',
                                                         'type': 'int'},
                                                  'yi': {'doc': 'storage for the index in y ',
                                                         'type': 'int'},
                                                  'zi': {'doc': 'storage for the index in z ',
                                                         'type': 'int'}},
                                      'args': [('index', 'int', 'in'),
                                               ('xi', 'int', 'out'),
                                               ('yi', 'int', 'out'),
                                               ('zi', 'int', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nThis is a utility routine for finding the coordinates of a cell in an array of fluid data given the index. The data in the fluid shape, such as color and density are passed back as single dimensional arrays of numeric values. This method converts the index value that refers to a cell's value in the single dimensional array into the three dimensional coordinates of the cell.",
                                      'inArgs': ['index'],
                                      'outArgs': ['xi', 'yi', 'zi'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'index': [],
                                                         'xi': ['&'],
                                                         'yi': ['&'],
                                                         'zi': ['&']},
                                      'types': {'index': 'int',
                                                'xi': 'int',
                                                'yi': 'int',
                                                'zi': 'int'}},
                                     {'argInfo': {'xi': {'doc': 'index in x ',
                                                         'type': 'int'},
                                                  'xres': {'doc': 'resolution in x ',
                                                           'type': 'int'},
                                                  'yi': {'doc': 'index in y ',
                                                         'type': 'int'},
                                                  'yres': {'doc': 'resolution in y ',
                                                           'type': 'int'},
                                                  'zi': {'doc': 'index in z ',
                                                         'type': 'int'},
                                                  'zres': {'doc': 'resolution in z',
                                                           'type': 'int'}},
                                      'args': [('xi', 'int', 'in'),
                                               ('yi', 'int', 'in'),
                                               ('zi', 'int', 'in'),
                                               ('xres', 'int', 'in'),
                                               ('yres', 'int', 'in'),
                                               ('zres', 'int', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThis is a utility routine for finding the index of a cell given the X, Y and Z resolutions. This is intended for use primarily with the velocity arrays, where the resolutions are different for each array. The X velocity array is one bigger in X, etc.',
                                      'inArgs': ['xi',
                                                 'yi',
                                                 'zi',
                                                 'xres',
                                                 'yres',
                                                 'zres'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Index in the single dimensional array ',
                                                     'qualifiers': [],
                                                     'type': 'int'},
                                      'returnType': 'int',
                                      'static': False,
                                      'typeQualifiers': {'xi': [],
                                                         'xres': [],
                                                         'yi': [],
                                                         'yres': [],
                                                         'zi': [],
                                                         'zres': []},
                                      'types': {'xi': 'int',
                                                'xres': 'int',
                                                'yi': 'int',
                                                'yres': 'int',
                                                'zi': 'int',
                                                'zres': 'int'}},
                                     {'argInfo': {'index': {'doc': 'index to convert into coordinates ',
                                                            'type': 'int'},
                                                  'xi': {'doc': 'storage for the index in x ',
                                                         'type': 'int'},
                                                  'xres': {'doc': 'resolution in x ',
                                                           'type': 'int'},
                                                  'yi': {'doc': 'storage for the index in y ',
                                                         'type': 'int'},
                                                  'yres': {'doc': 'resolution in y ',
                                                           'type': 'int'},
                                                  'zi': {'doc': 'storage for the index in z ',
                                                         'type': 'int'},
                                                  'zres': {'doc': 'resolution in z ',
                                                           'type': 'int'}},
                                      'args': [('index', 'int', 'in'),
                                               ('xres', 'int', 'in'),
                                               ('yres', 'int', 'in'),
                                               ('zres', 'int', 'in'),
                                               ('xi', 'int', 'out'),
                                               ('yi', 'int', 'out'),
                                               ('zi', 'int', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThis is a utility routine for finding the coordinates of a cell given the index, and the X, Y and Z resolutions. This is intended for use primarily with the velocity arrays, where the resolutions are different for each array. The X velocity array is one bigger in X, etc.',
                                      'inArgs': ['index',
                                                 'xres',
                                                 'yres',
                                                 'zres'],
                                      'outArgs': ['xi', 'yi', 'zi'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'index': [],
                                                         'xi': ['&'],
                                                         'xres': [],
                                                         'yi': ['&'],
                                                         'yres': [],
                                                         'zi': ['&'],
                                                         'zres': []},
                                      'types': {'index': 'int',
                                                'xi': 'int',
                                                'xres': 'int',
                                                'yi': 'int',
                                                'yres': 'int',
                                                'zi': 'int',
                                                'zres': 'int'}}],
                           'isAutoResize': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nIs this an autoresize fluid?',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                           'isResizeToEmitter': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nIf this is an autoresize fluid, should it also resize to the emitter',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                           'pressure': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method returns a pointer to the storage for the pressure data in the fluid. The size of this array can be obtained using the "gridSize" call. Note that the pressure data only exists if the velocity method is kStaticGrid or kDynamicGrid',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Pointer to the pressure data of the grid',
                                                        'qualifiers': ['*'],
                                                        'type': 'float'},
                                         'returnType': 'float',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                           'setColorMode': [{'argInfo': {'method': {'doc': 'method for determining the fluid color in the grid',
                                                                    'type': ('MFnFluid',
                                                                             'ColorMethod')}},
                                             'args': [('method',
                                                       ('MFnFluid',
                                                        'ColorMethod'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the modes by which the color values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                             'inArgs': ['method'],
                                             'inverse': ('getColorMode',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'method': []},
                                             'types': {'method': ('MFnFluid',
                                                                  'ColorMethod')}}],
                           'setCoordinateMode': [{'argInfo': {'method': {'doc': 'method for determining the fluid UVW coordinates in the grid',
                                                                         'type': ('MFnFluid',
                                                                                  'CoordinateMethod')}},
                                                  'args': [('method',
                                                            ('MFnFluid',
                                                             'CoordinateMethod'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the modes by which the UVW coordinate values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                                  'inArgs': ['method'],
                                                  'inverse': ('getCoordinateMode',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'method': []},
                                                  'types': {'method': ('MFnFluid',
                                                                       'CoordinateMethod')}}],
                           'setDensityMode': [{'argInfo': {'gradient': {'doc': 'gradient type, only used if the method is kGradient',
                                                                        'type': ('MFnFluid',
                                                                                 'FluidGradient')},
                                                           'method': {'doc': 'method for determining the fluid density in the grid ',
                                                                      'type': ('MFnFluid',
                                                                               'FluidMethod')}},
                                               'args': [('method',
                                                         ('MFnFluid',
                                                          'FluidMethod'),
                                                         'in'),
                                                        ('gradient',
                                                         ('MFnFluid',
                                                          'FluidGradient'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the modes by which the density values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                               'inArgs': ['method',
                                                          'gradient'],
                                               'inverse': ('getDensityMode',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'gradient': [],
                                                                  'method': []},
                                               'types': {'gradient': ('MFnFluid',
                                                                      'FluidGradient'),
                                                         'method': ('MFnFluid',
                                                                    'FluidMethod')}}],
                           'setFalloffMode': [{'argInfo': {'method': {'doc': 'method for determining the falloff value in the grid',
                                                                      'type': ('MFnFluid',
                                                                               'FalloffMethod')}},
                                               'args': [('method',
                                                         ('MFnFluid',
                                                          'FalloffMethod'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the modes by which the shader falloff values in the grid are determined. If the falloff grid is enabled, its values must be set by the user.',
                                               'inArgs': ['method'],
                                               'inverse': ('getFalloffMode',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'method': []},
                                               'types': {'method': ('MFnFluid',
                                                                    'FalloffMethod')}}],
                           'setFuelMode': [{'argInfo': {'gradient': {'doc': 'gradient type, only used if the method is kGradient',
                                                                     'type': ('MFnFluid',
                                                                              'FluidGradient')},
                                                        'method': {'doc': 'method for determining the fluid fuel in the grid ',
                                                                   'type': ('MFnFluid',
                                                                            'FluidMethod')}},
                                            'args': [('method',
                                                      ('MFnFluid',
                                                       'FluidMethod'),
                                                      'in'),
                                                     ('gradient',
                                                      ('MFnFluid',
                                                       'FluidGradient'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the modes by which the fuel values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation. The fuel value for a cell can be thought of as the amount of fuel contained in the cell that will be consumed during the simulation.',
                                            'inArgs': ['method',
                                                       'gradient'],
                                            'inverse': ('getFuelMode',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'gradient': [],
                                                               'method': []},
                                            'types': {'gradient': ('MFnFluid',
                                                                   'FluidGradient'),
                                                      'method': ('MFnFluid',
                                                                 'FluidMethod')}}],
                           'setSize': [{'argInfo': {'Xdim': {'doc': 'object space size in the x dimension ',
                                                             'type': 'double'},
                                                    'Xres': {'doc': 'number of fluid grid cells in the x dimension ',
                                                             'type': 'uint'},
                                                    'Ydim': {'doc': 'object space size in the y dimension ',
                                                             'type': 'double'},
                                                    'Yres': {'doc': 'number of fluid grid cells in the y dimension ',
                                                             'type': 'uint'},
                                                    'Zdim': {'doc': 'object space size in the z dimension ',
                                                             'type': 'double'},
                                                    'Zres': {'doc': 'number of fluid grid cells in the z dimension ',
                                                             'type': 'uint'},
                                                    'resample': {'doc': 'true if the previous contents of the grid should be scaled to fit the new size by resampling the previous data at the new resolution',
                                                                 'type': 'bool'}},
                                        'args': [('Xres', 'uint', 'in'),
                                                 ('Yres', 'uint', 'in'),
                                                 ('Zres', 'uint', 'in'),
                                                 ('Xdim',
                                                  'double',
                                                  'in'),
                                                 ('Ydim',
                                                  'double',
                                                  'in'),
                                                 ('Zdim',
                                                  'double',
                                                  'in'),
                                                 ('resample',
                                                  'bool',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the size and resolution of the grid. The resolution parameters control the number of cells in the fluid grid and the dimension parameters set the size of the fluid shape in object space.',
                                        'inArgs': ['Xres',
                                                   'Yres',
                                                   'Zres',
                                                   'Xdim',
                                                   'Ydim',
                                                   'Zdim',
                                                   'resample'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'Xdim': [],
                                                           'Xres': ['unsigned'],
                                                           'Ydim': [],
                                                           'Yres': ['unsigned'],
                                                           'Zdim': [],
                                                           'Zres': ['unsigned'],
                                                           'resample': []},
                                        'types': {'Xdim': 'double',
                                                  'Xres': 'uint',
                                                  'Ydim': 'double',
                                                  'Yres': 'uint',
                                                  'Zdim': 'double',
                                                  'Zres': 'uint',
                                                  'resample': 'bool'}},
                                       {'argInfo': {'Xdim': {'doc': 'object space size in the x dimension ',
                                                             'type': 'double'},
                                                    'Xres': {'doc': 'number of fluid grid cells in the x dimension ',
                                                             'type': 'uint'},
                                                    'Ydim': {'doc': 'object space size in the y dimension ',
                                                             'type': 'double'},
                                                    'Yres': {'doc': 'number of fluid grid cells in the y dimension ',
                                                             'type': 'uint'},
                                                    'resample': {'doc': 'true if the previous contents of the grid should be scaled to fit the new size by resampling the previous data at the new resolution',
                                                                 'type': 'bool'}},
                                        'args': [('Xres', 'uint', 'in'),
                                                 ('Yres', 'uint', 'in'),
                                                 ('Xdim',
                                                  'double',
                                                  'in'),
                                                 ('Ydim',
                                                  'double',
                                                  'in'),
                                                 ('resample',
                                                  'bool',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the size and resolution of the grid. The resolution parameters control the number of cells in the fluid grid and the dimension parameters set the size of the fluid shape in object space.',
                                        'inArgs': ['Xres',
                                                   'Yres',
                                                   'Xdim',
                                                   'Ydim',
                                                   'resample'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'Xdim': [],
                                                           'Xres': ['unsigned'],
                                                           'Ydim': [],
                                                           'Yres': ['unsigned'],
                                                           'resample': []},
                                        'types': {'Xdim': 'double',
                                                  'Xres': 'uint',
                                                  'Ydim': 'double',
                                                  'Yres': 'uint',
                                                  'resample': 'bool'}}],
                           'setTemperatureMode': [{'argInfo': {'gradient': {'doc': 'gradient type, only used if the method is kGradient',
                                                                            'type': ('MFnFluid',
                                                                                     'FluidGradient')},
                                                               'method': {'doc': 'method for determining the fluid temperature in the grid ',
                                                                          'type': ('MFnFluid',
                                                                                   'FluidMethod')}},
                                                   'args': [('method',
                                                             ('MFnFluid',
                                                              'FluidMethod'),
                                                             'in'),
                                                            ('gradient',
                                                             ('MFnFluid',
                                                              'FluidGradient'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the modes by which the temperature values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                                   'inArgs': ['method',
                                                              'gradient'],
                                                   'inverse': ('getTemperatureMode',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'gradient': [],
                                                                      'method': []},
                                                   'types': {'gradient': ('MFnFluid',
                                                                          'FluidGradient'),
                                                             'method': ('MFnFluid',
                                                                        'FluidMethod')}}],
                           'setVelocityMode': [{'argInfo': {'gradient': {'doc': 'gradient type, only used if the method is kGradient',
                                                                         'type': ('MFnFluid',
                                                                                  'FluidGradient')},
                                                            'method': {'doc': 'method for determining the fluid velocity in the grid ',
                                                                       'type': ('MFnFluid',
                                                                                'FluidMethod')}},
                                                'args': [('method',
                                                          ('MFnFluid',
                                                           'FluidMethod'),
                                                          'in'),
                                                         ('gradient',
                                                          ('MFnFluid',
                                                           'FluidGradient'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet the modes by which the velocity values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.',
                                                'inArgs': ['method',
                                                           'gradient'],
                                                'inverse': ('getVelocityMode',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'gradient': [],
                                                                   'method': []},
                                                'types': {'gradient': ('MFnFluid',
                                                                       'FluidGradient'),
                                                          'method': ('MFnFluid',
                                                                     'FluidMethod')}}],
                           'temperature': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method returns a pointer to the storage for the temperature data in the fluid. The size of this array can be obtained using the "gridSize" call.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Pointer to the temperature data of the grid',
                                                           'qualifiers': ['*'],
                                                           'type': 'float'},
                                            'returnType': 'float',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                           'toGridIndex': [{'argInfo': {'gridCoords': {'doc': 'the voxel indices, if the point falls inside a voxel ',
                                                                       'type': 'int3'},
                                                        'objectSpacePoint': {'doc': 'an object space location ',
                                                                             'type': 'MPoint'}},
                                            'args': [('objectSpacePoint',
                                                      'MPoint',
                                                      'in'),
                                                     ('gridCoords',
                                                      'int3',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nFor the given point in object space, get the grid indices of the voxel that it happens to lie in. If the point is outside the fluid, the method returns false, and the indices should not be used.',
                                            'inArgs': ['objectSpacePoint'],
                                            'outArgs': ['gridCoords'],
                                            'returnInfo': {'doc': 'True if the point is inside the fluid, false otherwise',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'gridCoords': ['&'],
                                                               'objectSpacePoint': ['const',
                                                                                    '&'],
                                                               'status': ['*']},
                                            'types': {'gridCoords': 'int3',
                                                      'objectSpacePoint': 'MPoint'}}],
                           'type': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nFunction set type. \r\n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': ('MFn',
                                                             'Type')},
                                     'returnType': ('MFn', 'Type'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                           'updateGrid': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nTells the fluid shape that the contents of the fluid grid has changed. It is necessary to call this routine after modifying internal fluid data via a pointer recieved from any of the access routines in this function set. Failure to call this will result in the fluid not drawing with your changes.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                           'velocityGridSizes': [{'argInfo': {'xsize': {'doc': 'storage for the x velocity grid size ',
                                                                        'type': 'int'},
                                                              'ysize': {'doc': 'storage for the y velocity grid size ',
                                                                        'type': 'int'},
                                                              'zsize': {'doc': 'storage for the z velocity grid size',
                                                                        'type': 'int'}},
                                                  'args': [('xsize',
                                                            'int',
                                                            'out'),
                                                           ('ysize',
                                                            'int',
                                                            'out'),
                                                           ('zsize',
                                                            'int',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the number of elements in the velocity grids. X velocity size = (x resolution+1 * y resolution * z resolution). Y velocity size = (x resolution * y resolution+1 * z resolution). Z velocity size = (x resolution * y resolution * z resolution+1).',
                                                  'inArgs': [],
                                                  'outArgs': ['xsize',
                                                              'ysize',
                                                              'zsize'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'xsize': ['&'],
                                                                     'ysize': ['&'],
                                                                     'zsize': ['&']},
                                                  'types': {'xsize': 'int',
                                                            'ysize': 'int',
                                                            'zsize': 'int'}}],
                           'voxelCenterPosition': [{'argInfo': {'objectSpacePoint': {'doc': 'the object space location',
                                                                                     'type': 'MPoint'},
                                                                'xi': {'doc': 'the voxel x index ',
                                                                       'type': 'int'},
                                                                'yi': {'doc': 'the voxel y index ',
                                                                       'type': 'int'},
                                                                'zi': {'doc': 'the voxel z index ',
                                                                       'type': 'int'}},
                                                    'args': [('xi',
                                                              'int',
                                                              'in'),
                                                             ('yi',
                                                              'int',
                                                              'in'),
                                                             ('zi',
                                                              'int',
                                                              'in'),
                                                             ('objectSpacePoint',
                                                              'MPoint',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nFor the given voxel, get the location of the center in object space. If the voxel indices are not valid, the point may not be set to a valid point',
                                                    'inArgs': ['xi',
                                                               'yi',
                                                               'zi'],
                                                    'outArgs': ['objectSpacePoint'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'objectSpacePoint': ['&'],
                                                                       'xi': [],
                                                                       'yi': [],
                                                                       'zi': []},
                                                    'types': {'objectSpacePoint': 'MPoint',
                                                              'xi': 'int',
                                                              'yi': 'int',
                                                              'zi': 'int'}}]},
               'pymelEnums': {'ColorMethod': "Enum('ColorMethod', [('useShadingColor', 0), ('kUseShadingColor', 0), ('staticColorGrid', 1), ('kStaticColorGrid', 1), ('dynamicColorGrid', 2), ('kDynamicColorGrid', 2)], multiKeys=True)",
                              'CoordinateMethod': "Enum('CoordinateMethod', [('fixed', 0), ('kFixed', 0), ('grid', 1), ('kGrid', 1)], multiKeys=True)",
                              'FalloffMethod': "Enum('FalloffMethod', [('noFalloffGrid', 0), ('kNoFalloffGrid', 0), ('staticFalloffGrid', 1), ('kStaticFalloffGrid', 1)], multiKeys=True)",
                              'FluidGradient': "Enum('FluidGradient', [('constant', 0), ('kConstant', 0), ('XGradient', 1), ('kXGradient', 1), ('YGradient', 2), ('kYGradient', 2), ('ZGradient', 3), ('kZGradient', 3), ('negXGradient', 4), ('kNegXGradient', 4), ('negYGradient', 5), ('kNegYGradient', 5), ('negZGradient', 6), ('kNegZGradient', 6), ('centerGradient', 7), ('kCenterGradient', 7)], multiKeys=True)",
                              'FluidMethod': "Enum('FluidMethod', [('zero', 0), ('kZero', 0), ('staticGrid', 1), ('kStaticGrid', 1), ('dynamicGrid', 2), ('kDynamicGrid', 2), ('gradient', 3), ('kGradient', 3)], multiKeys=True)"}},
  'MFnFreePointTriadManip': {'enums': {'ManipPlane': {'valueDocs': {'XYPlane': 'X-Y Plane.',
                                                                    'XZPlane': 'X-Z Plane.',
                                                                    'YZPlane': 'Y-Z Plane.',
                                                                    'kViewPlane': 'View Plane.',
                                                                    'kXYPlane': 'X-Y Plane.',
                                                                    'kXZPlane': 'X-Z Plane.',
                                                                    'kYZPlane': 'Y-Z Plane.',
                                                                    'viewPlane': 'View Plane.'},
                                                      'values': "Enum('ManipPlane', {'kYZPlane': 0, 'kXZPlane': 1, 'kXYPlane': 2, 'kViewPlane': 3})"}},
                             'methods': {'className': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nClass name. \r\n',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'char'},
                                                        'returnType': 'char',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                         'connectToPointPlug': [{'argInfo': {'pointPlug': {'doc': 'the point plug',
                                                                                           'type': 'MPlug'}},
                                                                 'args': [('pointPlug',
                                                                           'MPlug',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nConnect to the point plug. The data type corresponding to the pointPlug is  MFnNumericData::k3Double .',
                                                                 'inArgs': ['pointPlug'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'pointPlug': ['&']},
                                                                 'types': {'pointPlug': 'MPlug'}}],
                                         'create': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nCreates a new FreePointTriadManip. This function set's object is set to be the new manipulator.",
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Newly created FreePointTriadManip',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}},
                                                    {'argInfo': {'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                               'type': 'MString'},
                                                                 'pointName': {'doc': 'Label for the position value which appears in the feedback line. ',
                                                                               'type': 'MString'}},
                                                     'args': [('manipName',
                                                               'MString',
                                                               'in'),
                                                              ('pointName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nCreates a new FreePointTriadManip. This function set's object is set to be the new manipulator.",
                                                     'inArgs': ['manipName',
                                                                'pointName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Newly created FreePointTriadManip.',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'manipName': ['const',
                                                                                      '&'],
                                                                        'pointName': ['const',
                                                                                      '&']},
                                                     'types': {'manipName': 'MString',
                                                               'pointName': 'MString'}}],
                                         'isDrawAxesOn': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns whether or not the axes of the FreePointTriadManip are being drawn. By default the axes are drawn.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' true the axes of the FreePointTriadManip are being drawn  false the axes of the FreePointTriadManip are not being drawn  ',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                         'isKeyframeAllOn': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns whether or not the FreePointTriadManip is in keyframeAll mode.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': ' true the FreePointTriadManip is in keyframeAll mode  false the FreePointTriadManip is not in keyframeAll mode  ',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                         'isSnapModeOn': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns whether or not the FreePointTriadManip is in snap mode.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' true the FreePointTriadManip is in snap mode  false the FreePointTriadManip is not in snap mode  ',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                         'pointIndex': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the index of the point of the FreePointTriadManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Point index',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                         'setDirection': [{'argInfo': {'direction': {'doc': 'the new direction for freePointTriadManip.',
                                                                                     'type': 'MVector'}},
                                                           'args': [('direction',
                                                                     'MVector',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSets the orientation of the FreePointTriadManip.',
                                                           'inArgs': ['direction'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'direction': ['const',
                                                                                            '&']},
                                                           'types': {'direction': 'MVector'}}],
                                         'setDrawArrowHead': [{'argInfo': {'state': {'doc': 'whether or not drawArrowHead is on',
                                                                                     'type': 'bool'}},
                                                               'args': [('state',
                                                                         'bool',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nSets whether or not drawArrowHead is on.',
                                                               'inArgs': ['state'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'state': []},
                                                               'types': {'state': 'bool'}}],
                                         'setDrawAxes': [{'argInfo': {'state': {'doc': 'whether or not the axes should be drawn',
                                                                                'type': 'bool'}},
                                                          'args': [('state',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSets whether or not to draw the axes of the FreePointTriadManip. By default the axes are drawn.',
                                                          'inArgs': ['state'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'state': []},
                                                          'types': {'state': 'bool'}}],
                                         'setGlobalTriadPlane': [{'argInfo': {'whichPlane': {'doc': 'which plane to use as the global triad plane',
                                                                                             'type': ('MFnFreePointTriadManip',
                                                                                                      'ManipPlane')}},
                                                                  'args': [('whichPlane',
                                                                            ('MFnFreePointTriadManip',
                                                                             'ManipPlane'),
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nSets which plane to use as the global triad plane. The global triad plane does not change until the context switches.',
                                                                  'inArgs': ['whichPlane'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'whichPlane': []},
                                                                  'types': {'whichPlane': ('MFnFreePointTriadManip',
                                                                                           'ManipPlane')}}],
                                         'setKeyframeAll': [{'argInfo': {'state': {'doc': 'whether or not keyframeAll is on',
                                                                                   'type': 'bool'}},
                                                             'args': [('state',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSets whether or not keyframeAll is on.',
                                                             'inArgs': ['state'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'state': []},
                                                             'types': {'state': 'bool'}}],
                                         'setPoint': [{'argInfo': {'pointValue': {'doc': 'The new value of the point manipValue',
                                                                                  'type': 'MPoint'}},
                                                       'args': [('pointValue',
                                                                 'MPoint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet the point manipulator value to the given vector. This method can be called in the  MPxManipContainer::connectToDependNode()  method to set the initial position for the manipulator.',
                                                       'inArgs': ['pointValue'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'pointValue': ['const',
                                                                                         '&']},
                                                       'types': {'pointValue': 'MPoint'}}],
                                         'setSnapMode': [{'argInfo': {'state': {'doc': 'whether or not the FreePointTriadManip should be in snap mode',
                                                                                'type': 'bool'}},
                                                          'args': [('state',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nSets whether or not to the FreePointTriadManip should be in snap mode.',
                                                          'inArgs': ['state'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'state': []},
                                                          'types': {'state': 'bool'}}],
                                         'type': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nFunction set type. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': ('MFn',
                                                                           'Type')},
                                                   'returnType': ('MFn',
                                                                  'Type'),
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                             'pymelEnums': {'ManipPlane': "Enum('ManipPlane', [('YZPlane', 0), ('kYZPlane', 0), ('XZPlane', 1), ('kXZPlane', 1), ('XYPlane', 2), ('kXYPlane', 2), ('viewPlane', 3), ('kViewPlane', 3)], multiKeys=True)"}},
  'MFnGenericAttribute': {'enums': {},
                          'methods': {'addAccept': [{'argInfo': {'id': {'doc': 'id of new type',
                                                                        'type': 'MTypeId'}},
                                                     'args': [('id',
                                                               'MTypeId',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nAdd a new connection type that this attribute can accept. This method takes the type id (iff tag) of the data objects that can be accepted.',
                                                     'inArgs': ['id'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'id': ['const',
                                                                               '&']},
                                                     'types': {'id': 'MTypeId'}}],
                                      'addDataAccept': [{'argInfo': {'newType': {'doc': 'new type',
                                                                                 'type': ('MFnData',
                                                                                          'Type')}},
                                                         'args': [('newType',
                                                                   ('MFnData',
                                                                    'Type'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nAdd a new connection type that this attribute can accept.',
                                                         'inArgs': ['newType'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'newType': []},
                                                         'types': {'newType': ('MFnData',
                                                                               'Type')}}],
                                      'addNumericDataAccept': [{'argInfo': {'newType': {'doc': 'new type',
                                                                                        'type': ('MFnNumericData',
                                                                                                 'Type')}},
                                                                'args': [('newType',
                                                                          ('MFnNumericData',
                                                                           'Type'),
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nAdd a new connection type that this attribute can accept.',
                                                                'inArgs': ['newType'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {'newType': []},
                                                                'types': {'newType': ('MFnNumericData',
                                                                                      'Type')}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nClass name. \r\n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'create': [{'argInfo': {'brief': {'doc': 'Short name of the attribute. ',
                                                                        'type': 'MString'},
                                                              'full': {'doc': 'Long name of the attribute. ',
                                                                       'type': 'MString'}},
                                                  'args': [('full',
                                                            'MString',
                                                            'in'),
                                                           ('brief',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nCreates a new generic attribute.',
                                                  'inArgs': ['full',
                                                             'brief'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'New attribute.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'brief': ['const',
                                                                               '&'],
                                                                     'full': ['const',
                                                                              '&']},
                                                  'types': {'brief': 'MString',
                                                            'full': 'MString'}}],
                                      'removeAccept': [{'argInfo': {'id': {'doc': 'id of old type that is no longer accepted',
                                                                           'type': 'MTypeId'}},
                                                        'args': [('id',
                                                                  'MTypeId',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRemove one of the types that this attribute can accept. This method takes the type id (iff tag) of the data objects that can no longer be accepted.',
                                                        'inArgs': ['id'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'id': ['const',
                                                                                  '&']},
                                                        'types': {'id': 'MTypeId'}}],
                                      'removeDataAccept': [{'argInfo': {'oldType': {'doc': 'old type that is no longer accepted',
                                                                                    'type': ('MFnData',
                                                                                             'Type')}},
                                                            'args': [('oldType',
                                                                      ('MFnData',
                                                                       'Type'),
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nRemove one of the types that this attribute can accept.',
                                                            'inArgs': ['oldType'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'oldType': []},
                                                            'types': {'oldType': ('MFnData',
                                                                                  'Type')}}],
                                      'removeNumericDataAccept': [{'argInfo': {'oldType': {'doc': 'old type that is no longer accepted',
                                                                                           'type': ('MFnNumericData',
                                                                                                    'Type')}},
                                                                   'args': [('oldType',
                                                                             ('MFnNumericData',
                                                                              'Type'),
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nRemove one of the types that this attribute can accept.',
                                                                   'inArgs': ['oldType'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'oldType': []},
                                                                   'types': {'oldType': ('MFnNumericData',
                                                                                         'Type')}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nFunction set type. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {}},
  'MFnGeometryData': {'enums': {},
                      'invertibles': [('setMatrix', 'getMatrix'),
                                      ('setObjectGroupComponent',
                                       'objectGroupComponent')],
                      'methods': {'addObjectGroup': [{'argInfo': {'id': {'doc': 'group id.',
                                                                         'type': 'uint'}},
                                                      'args': [('id',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nThis method adds an object group with the given id to the object.',
                                                      'inArgs': ['id'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'id': ['unsigned']},
                                                      'types': {'id': 'uint'}}],
                                  'addObjectGroupComponent': [{'argInfo': {'component': {'doc': 'new component to be added to the specified object group. The component should be an MObject created from any function set derived from MFnComponent (ie. MFnSingleIndexedComponent, MFnDoubleIndexedComponent, MFnTripleIndexedComponent)',
                                                                                         'type': 'MObject'},
                                                                           'id': {'doc': 'id of object group to add to ',
                                                                                  'type': 'uint'}},
                                                               'args': [('id',
                                                                         'uint',
                                                                         'in'),
                                                                        ('component',
                                                                         'MObject',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nThis method adds the members of the given component to the object group with the given id.',
                                                               'inArgs': ['id',
                                                                          'component'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'component': ['&'],
                                                                                  'id': ['unsigned']},
                                                               'types': {'component': 'MObject',
                                                                         'id': 'uint'}}],
                                  'changeObjectGroupId': [{'argInfo': {'destId': {'doc': 'new id to set',
                                                                                  'type': 'uint'},
                                                                       'sourceId': {'doc': 'id to change ',
                                                                                    'type': 'uint'}},
                                                           'args': [('sourceId',
                                                                     'uint',
                                                                     'in'),
                                                                    ('destId',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nThis method changes the id of the object group with the given id to the new id.',
                                                           'inArgs': ['sourceId',
                                                                      'destId'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'destId': ['unsigned'],
                                                                              'sourceId': ['unsigned']},
                                                           'types': {'destId': 'uint',
                                                                     'sourceId': 'uint'}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nClass name. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'copyObjectGroups': [{'argInfo': {'inGeom': {'doc': 'the geometry data to be copied',
                                                                               'type': 'MObject'}},
                                                        'args': [('inGeom',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nCopies the object groups from the given geometry data object.',
                                                        'inArgs': ['inGeom'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'inGeom': ['&']},
                                                        'types': {'inGeom': 'MObject'}}],
                                  'getMatrix': [{'argInfo': {'matrix': {'doc': 'storage for the returned matrix',
                                                                        'type': 'MMatrix'}},
                                                 'args': [('matrix',
                                                           'MMatrix',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nGet the matrix associated with the geometry data.',
                                                 'inArgs': [],
                                                 'inverse': ('setMatrix',
                                                             False),
                                                 'outArgs': ['matrix'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'matrix': ['&']},
                                                 'types': {'matrix': 'MMatrix'}}],
                                  'hasObjectGroup': [{'argInfo': {'id': {'doc': 'group id. ',
                                                                         'type': 'uint'}},
                                                      'args': [('id',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nThis method returns true if an object group with the given id is contained in the data.',
                                                      'inArgs': ['id'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True is there is an object group with the given id, false otherwise',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'id': ['unsigned']},
                                                      'types': {'id': 'uint'}}],
                                  'matrixIsIdentity': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturn true if the matrix is the identity.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'True if the matrix for the geometry is identity, false otherwise',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                  'matrixIsNotIdentity': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturn true if the matrix is different from identity.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'True if the matrix for the geometry is NOT the identity, false otherwise',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                  'objectGroup': [{'argInfo': {'index': {'doc': 'index in the group array. ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\nThis method returns the id of the i'th object group contained by the object.",
                                                   'inArgs': [],
                                                   'outArgs': ['index'],
                                                   'returnInfo': {'doc': "The id of the i'th object group",
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                                  'objectGroupComponent': [{'argInfo': {'id': {'doc': 'group id. ',
                                                                               'type': 'uint'}},
                                                            'args': [('id',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nThis method returns a component which contains the members of the object group with the given id.',
                                                            'inArgs': ['id'],
                                                            'inverse': ('setObjectGroupComponent',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'A component containing the members of the specified object group',
                                                                           'qualifiers': [],
                                                                           'type': 'MObject'},
                                                            'returnType': 'MObject',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'id': ['unsigned']},
                                                            'types': {'id': 'uint'}}],
                                  'objectGroupCount': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nThis method returns the number of object groups contained by the object.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The number of object groups',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                  'objectGroupType': [{'argInfo': {'id': {'doc': 'group id. ',
                                                                          'type': 'uint'}},
                                                       'args': [('id',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nThis method returns the type of the component that the object group with the given id contains.',
                                                       'inArgs': ['id'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The type of the specified object group component',
                                                                      'qualifiers': [],
                                                                      'type': ('MFn',
                                                                               'Type')},
                                                       'returnType': ('MFn',
                                                                      'Type'),
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'id': ['unsigned']},
                                                       'types': {'id': 'uint'}}],
                                  'removeObjectGroup': [{'argInfo': {'id': {'doc': 'group id.',
                                                                            'type': 'uint'}},
                                                         'args': [('id',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nThis method removes an object group with the given id from the object.',
                                                         'inArgs': ['id'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'id': ['unsigned']},
                                                         'types': {'id': 'uint'}}],
                                  'removeObjectGroupComponent': [{'argInfo': {'component': {'doc': 'component specifying the members to be removed. The component should be an MObject created from any function set derived from MFnComponent (ie. MFnSingleIndexedComponent, MFnDoubleIndexedComponent, MFnTripleIndexedComponent)',
                                                                                            'type': 'MObject'},
                                                                              'id': {'doc': 'id of object group to be changed ',
                                                                                     'type': 'uint'}},
                                                                  'args': [('id',
                                                                            'uint',
                                                                            'in'),
                                                                           ('component',
                                                                            'MObject',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nThis method removes the members of the given component from the object group with the given id.',
                                                                  'inArgs': ['id',
                                                                             'component'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'component': ['&'],
                                                                                     'id': ['unsigned']},
                                                                  'types': {'component': 'MObject',
                                                                            'id': 'uint'}}],
                                  'setMatrix': [{'argInfo': {'matrix': {'doc': 'the new matrix to be set',
                                                                        'type': 'MMatrix'}},
                                                 'args': [('matrix',
                                                           'MMatrix',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReset the matrix the the specified matrix and set the identity flag if the new matrix is the identity.',
                                                 'inArgs': ['matrix'],
                                                 'inverse': ('getMatrix',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'matrix': ['const',
                                                                               '&']},
                                                 'types': {'matrix': 'MMatrix'}}],
                                  'setObjectGroupComponent': [{'argInfo': {'component': {'doc': 'new component for specified object group. The component should be an MObject created from any function set derived from MFnComponent (ie. MFnSingleIndexedComponent, MFnDoubleIndexedComponent, MFnTripleIndexedComponent)',
                                                                                         'type': 'MObject'},
                                                                           'id': {'doc': 'id of object group to set ',
                                                                                  'type': 'uint'}},
                                                               'args': [('id',
                                                                         'uint',
                                                                         'in'),
                                                                        ('component',
                                                                         'MObject',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nThis method sets the members of the object group with the given id to be only those in the given component.',
                                                               'inArgs': ['id',
                                                                          'component'],
                                                               'inverse': ('objectGroupComponent',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'component': ['&'],
                                                                                  'id': ['unsigned']},
                                                               'types': {'component': 'MObject',
                                                                         'id': 'uint'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFunction set type. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'objectGroupComponent': 'getObjectGroupComponent'}},
  'MFnGeometryFilter': {'enums': {},
                        'invertibles': [('setEnvelope', 'envelope')],
                        'methods': {'deformerSet': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturns the set containing the objects that are deformed. Adding new components to the deformer set will cause them to be deformed. Removing components from the deformer set will prevent them from being influenced by the deformer.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The set containing the objects that are deformed',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                    'envelope': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the envelope value.',
                                                  'inArgs': [],
                                                  'inverse': ('setEnvelope',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The envelope value',
                                                                 'qualifiers': [],
                                                                 'type': 'float'},
                                                  'returnType': 'float',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'getInputGeometry': [{'argInfo': {'geomList': {'doc': 'storage for the returned array',
                                                                                   'type': 'MObjectArray'}},
                                                          'args': [('geomList',
                                                                    'MObjectArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nThis method returns the input geometry for the deformer by traversing the graph to find upstream shape nodes. It is possible for there to be nodes in between the shape and the deformer so that the returned shape may have a different topology or tweaks then the input data to the deformer. If the actual input geometry data for the deformer is required, this information can be accessed by using  MPlug::getValue()  to query the inputGeometry attribute on the deformer.',
                                                          'inArgs': [],
                                                          'outArgs': ['geomList'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'geomList': ['&']},
                                                          'types': {'geomList': 'MObjectArray'}}],
                                    'getOutputGeometry': [{'argInfo': {'geomList': {'doc': 'storage for the returned array',
                                                                                    'type': 'MObjectArray'}},
                                                           'args': [('geomList',
                                                                     'MObjectArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nThe output geometry is packed into the provided list of MObjects. Each of the MObjects will be a DAG node.',
                                                           'inArgs': [],
                                                           'outArgs': ['geomList'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'geomList': ['&']},
                                                           'types': {'geomList': 'MObjectArray'}}],
                                    'getPathAtIndex': [{'argInfo': {'dagPath': {'doc': 'the DAG path whose index is requested',
                                                                                'type': 'MDagPath'},
                                                                    'index': {'doc': 'the plug index ',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in'),
                                                                 ('dagPath',
                                                                  'MDagPath',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nThe DAG path of the output geometry at the specified plug index is put in the dagPath argument.',
                                                        'inArgs': ['index'],
                                                        'outArgs': ['dagPath'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'dagPath': ['&'],
                                                                           'index': ['unsigned']},
                                                        'types': {'dagPath': 'MDagPath',
                                                                  'index': 'uint'}}],
                                    'groupIdAtIndex': [{'argInfo': {'index': {'doc': 'the plug index for which the groupId is requested ',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturns the groupId at the specified plug index.',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The groupId at the specified index',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'index': ['unsigned']},
                                                        'types': {'index': 'uint'}}],
                                    'indexForGroupId': [{'argInfo': {'groupId': {'doc': 'the groupId for the plug index ',
                                                                                 'type': 'uint'}},
                                                         'args': [('groupId',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the plug index corresponding to the groupId.',
                                                         'inArgs': ['groupId'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The plug index corresponding to the groupId',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'groupId': ['unsigned']},
                                                         'types': {'groupId': 'uint'}}],
                                    'indexForOutputConnection': [{'argInfo': {'connectionIndex': {'doc': 'the connection index ',
                                                                                                  'type': 'uint'}},
                                                                  'args': [('connectionIndex',
                                                                            'uint',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': "\nReturns the plug index corresponding to the connection index. The connection index is the index specifying the nth output connection. The plug index (logical index) is the sparse array index used by many of MFnGeometryFilter's methods and in MEL scripts. The connection index is 0-based, hence, the maximum value of the connection index is numOutputs - 1.",
                                                                  'inArgs': ['connectionIndex'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'The plug index corresponding to the connection index',
                                                                                 'qualifiers': [],
                                                                                 'type': 'int'},
                                                                  'returnType': 'int',
                                                                  'static': False,
                                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                     'connectionIndex': ['unsigned']},
                                                                  'types': {'connectionIndex': 'uint'}}],
                                    'indexForOutputShape': [{'argInfo': {'shape': {'doc': 'the shape for which the plug index is requested ',
                                                                                   'type': 'MObject'}},
                                                             'args': [('shape',
                                                                       'MObject',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nReturns the plug index for the specified output shape.',
                                                             'inArgs': ['shape'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The plug index leading to the specified shape',
                                                                            'qualifiers': [],
                                                                            'type': 'int'},
                                                             'returnType': 'int',
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'shape': ['const',
                                                                                          '&']},
                                                             'types': {'shape': 'MObject'}}],
                                    'inputShapeAtIndex': [{'argInfo': {'index': {'doc': 'the plug index for the input shape ',
                                                                                 'type': 'uint'}},
                                                           'args': [('index',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturns the input shape corresponding to the plug index.',
                                                           'inArgs': ['index'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The input shape corresponding to the plug index',
                                                                          'qualifiers': [],
                                                                          'type': 'MObject'},
                                                           'returnType': 'MObject',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'index': ['unsigned']},
                                                           'types': {'index': 'uint'}}],
                                    'numOutputConnections': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nReturns the number of output geometries connected to this node. This is typically equal to the number of input geometries unless an input or output geometry has been deleted, or a connection to an input or output geometry has been broken.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The number of outputs',
                                                                             'qualifiers': [],
                                                                             'type': 'int'},
                                                              'returnType': 'int',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                    'outputShapeAtIndex': [{'argInfo': {'index': {'doc': 'the plug index for the output shape ',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturns the output shape corresponding to the plug index',
                                                            'inArgs': ['index'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The output shape corresponding to the plug index',
                                                                           'qualifiers': [],
                                                                           'type': 'MObject'},
                                                            'returnType': 'MObject',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'index': ['unsigned']},
                                                            'types': {'index': 'uint'}}],
                                    'setEnvelope': [{'argInfo': {'envelope': {'doc': 'envelope value',
                                                                              'type': 'float'}},
                                                     'args': [('envelope',
                                                               'float',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSets the envelope value.',
                                                     'inArgs': ['envelope'],
                                                     'inverse': ('envelope',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'envelope': []},
                                                     'types': {'envelope': 'float'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nFunction set type. \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {},
                        'pymelMethods': {'envelope': 'getEnvelope'}},
  'MFnGravityField': {'enums': {},
                      'invertibles': [('setDirection', 'direction')],
                      'methods': {'direction': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the direction of the gravitational force.',
                                                 'inArgs': [],
                                                 'inverse': ('setDirection',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A vector representing direction.',
                                                                'qualifiers': [],
                                                                'type': 'MVector'},
                                                 'returnType': 'MVector',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                  'setDirection': [{'argInfo': {'gravityDirection': {'doc': 'A vector representing direction.',
                                                                                     'type': 'MVector'}},
                                                    'args': [('gravityDirection',
                                                              'MVector',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets the direction vector of the gravitational force.',
                                                    'inArgs': ['gravityDirection'],
                                                    'inverse': ('direction',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'gravityDirection': ['const',
                                                                                            '&']},
                                                    'types': {'gravityDirection': 'MVector'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFunction set type. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'direction': 'getDirection'}},
  'MFnHikEffector': {'enums': {},
                     'invertibles': [('setEffColor', 'getEffColor'),
                                     ('setPivotOffset', 'getPivotOffset')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nClass name. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {'parent': {'doc': 'parent DAG node (usually none) ',
                                                                    'type': 'MObject'}},
                                             'args': [('parent',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {'parent': 'MObject::kNullObj'},
                                             'deprecated': False,
                                             'doc': '\nCreates a new fbik effector.',
                                             'inArgs': ['parent'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A handle to the new object',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'parent': []},
                                             'types': {'parent': 'MObject'}}],
                                 'getAuxiliaryEffectors': [{'argInfo': {'effs': {'doc': 'the auxiliary effectors for this effector',
                                                                                 'type': 'MObjectArray'}},
                                                            'args': [('effs',
                                                                      'MObjectArray',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturns an array of the auxiliary effectors associated with this effector. Auxiliary effectors are used by humanIK to act as additional pivots.',
                                                            'inArgs': [],
                                                            'outArgs': ['effs'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'effs': ['&']},
                                                            'types': {'effs': 'MObjectArray'}}],
                                 'getEffColor': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nRetrieve the cached humanIK color of this effector.',
                                                  'inArgs': [],
                                                  'inverse': ('setEffColor',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Pivot offset vector.',
                                                                 'qualifiers': [],
                                                                 'type': 'MColor'},
                                                  'returnType': 'MColor',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'getPivotOffset': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieve the pivot offset of this effector.',
                                                     'inArgs': [],
                                                     'inverse': ('setPivotOffset',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Pivot offset vector.',
                                                                    'qualifiers': [],
                                                                    'type': 'MVector'},
                                                     'returnType': 'MVector',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                 'setEffColor': [{'argInfo': {'color': {'doc': 'the new color',
                                                                        'type': 'MColor'}},
                                                  'args': [('color',
                                                            'MColor',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nSet the humanIK color for this effector.',
                                                  'inArgs': ['color'],
                                                  'inverse': ('getEffColor',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['const',
                                                                               '&']},
                                                  'types': {'color': 'MColor'}}],
                                 'setPivotOffset': [{'argInfo': {'vector': {'doc': 'the new pivot offset',
                                                                            'type': 'MVector'}},
                                                     'args': [('vector',
                                                               'MVector',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSet the pivot offset for this effector.',
                                                     'inArgs': ['vector'],
                                                     'inverse': ('getPivotOffset',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'vector': ['const',
                                                                                   '&']},
                                                     'types': {'vector': 'MVector'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnIkEffector': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nClass name. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {'parent': {'doc': 'parent DAG node (should be a joint) ',
                                                                   'type': 'MObject'}},
                                            'args': [('parent',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {'parent': 'MObject::kNullObj'},
                                            'deprecated': False,
                                            'doc': '\nCreates a new end effector. For the effector to work properly, it should be given a joint as the parent. It should be given the joint before the last bone.',
                                            'inArgs': ['parent'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A handle to the new object',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'parent': []},
                                            'types': {'parent': 'MObject'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nFunction set type. \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {}},
  'MFnIkHandle': {'enums': {'Stickiness': {'valueDocs': {'kStickyOff': "Handle will move with skeleton's root.",
                                                         'kStickyOn': 'Handle will try to stay where it is.',
                                                         'kSuperSticky': 'Not used.',
                                                         'stickyOff': "Handle will move with skeleton's root.",
                                                         'stickyOn': 'Handle will try to stay where it is.',
                                                         'superSticky': 'Not used.'},
                                           'values': "Enum('Stickiness', {'kStickyOff': 0, 'kStickyOn': 1, 'kSuperSticky': 2})"}},
                  'invertibles': [('setPriority', 'priority'),
                                  ('setWeight', 'weight'),
                                  ('setSolver', 'solver'),
                                  ('setEffector', 'getEffector'),
                                  ('setStartJoint', 'getStartJoint'),
                                  ('setStickiness', 'stickiness')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nClass name. \r\n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'create': [{'argInfo': {'effector': {'doc': 'a path to the end-effector (last joint) in the chain ',
                                                                   'type': 'MDagPath'},
                                                      'startJoint': {'doc': 'a path to the start joint in the joint chain ',
                                                                     'type': 'MDagPath'}},
                                          'args': [('startJoint',
                                                    'MDagPath',
                                                    'in'),
                                                   ('effector',
                                                    'MDagPath',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nCreates a new ik handle. The effector and startJoint specify the joint chain controlled by this handle. The effector is the joint that is moved by the handle forcing the solver to recalculate the joint chain.',
                                          'inArgs': ['startJoint',
                                                     'effector'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'effector': ['&'],
                                                             'startJoint': ['&']},
                                          'types': {'effector': 'MDagPath',
                                                    'startJoint': 'MDagPath'}}],
                              'getEffector': [{'argInfo': {'effectorPath': {'doc': 'Storage for the effector path',
                                                                            'type': 'MDagPath'}},
                                               'args': [('effectorPath',
                                                         'MDagPath',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nGet a dag path to the end-effector of the handle's joint chain.",
                                               'inArgs': [],
                                               'inverse': ('setEffector',
                                                           False),
                                               'outArgs': ['effectorPath'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'effectorPath': ['&']},
                                               'types': {'effectorPath': 'MDagPath'}}],
                              'getStartJoint': [{'argInfo': {'jointPath': {'doc': 'storage for the dag path to the joint',
                                                                           'type': 'MDagPath'}},
                                                 'args': [('jointPath',
                                                           'MDagPath',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nThis method will get a dag path to the starting joint of the handle's joint chain.",
                                                 'inArgs': [],
                                                 'inverse': ('setStartJoint',
                                                             False),
                                                 'outArgs': ['jointPath'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'jointPath': ['&']},
                                                 'types': {'jointPath': 'MDagPath'}}],
                              'poWeight': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGets the position/orientation weight of a handle. This is used to compute the "distance" between the goal position and the end-effector position.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The position/orientation weight',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                              'priority': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGet the priority of this handle in case a solution is affected by more than one handle.',
                                            'inArgs': [],
                                            'inverse': ('setPriority',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The priority of this handle',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                              'setEffector': [{'argInfo': {'effectorPath': {'doc': 'The path for the effector',
                                                                            'type': 'MDagPath'}},
                                               'args': [('effectorPath',
                                                         'MDagPath',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nSet the dag path to the end-effector of the handle's joint chain. The end-effector/joint must be on the same skeletal chain as the start joint or this method will fail.",
                                               'inArgs': ['effectorPath'],
                                               'inverse': ('getEffector',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'effectorPath': ['const',
                                                                                   '&']},
                                               'types': {'effectorPath': 'MDagPath'}}],
                              'setPOWeight': [{'argInfo': {'poWeight': {'doc': 'The position/orientation weight to be set',
                                                                        'type': 'double'}},
                                               'args': [('poWeight',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets the position/orientation weight of a handle. This is used to compute the "distance" between the goal position and the end-effector position.',
                                               'inArgs': ['poWeight'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'poWeight': []},
                                               'types': {'poWeight': 'double'}}],
                              'setPriority': [{'argInfo': {'priority': {'doc': 'The priority to set for this handle',
                                                                        'type': 'uint'}},
                                               'args': [('priority',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the priority of this handle in case a solution is affected by more than one handle',
                                               'inArgs': ['priority'],
                                               'inverse': ('priority',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'priority': ['unsigned']},
                                               'types': {'priority': 'uint'}}],
                              'setSolver': [{'argInfo': {'solver': {'doc': 'The solver for this handle',
                                                                    'type': 'MObject'}},
                                             'args': [('solver',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the solver for this handle.',
                                             'inArgs': ['solver'],
                                             'inverse': ('solver', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'solver': ['const',
                                                                           '&']},
                                             'types': {'solver': 'MObject'}},
                                            {'argInfo': {'solverName': {'doc': 'The type name of the solver to be set',
                                                                        'type': 'MString'}},
                                             'args': [('solverName',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the solver associated with this handle by name.',
                                             'inArgs': ['solverName'],
                                             'inverse': ('solver', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'solverName': ['const',
                                                                               '&']},
                                             'types': {'solverName': 'MString'}}],
                              'setStartJoint': [{'argInfo': {'jointPath': {'doc': 'The dag path to the joint that will be set',
                                                                           'type': 'MDagPath'}},
                                                 'args': [('jointPath',
                                                           'MDagPath',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nThis method will set the dag path for the starting joint of the handle's joint chain. The start joint must be on the same skeletal chain as the end effector or this method will fail.",
                                                 'inArgs': ['jointPath'],
                                                 'inverse': ('getStartJoint',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'jointPath': ['const',
                                                                                  '&']},
                                                 'types': {'jointPath': 'MDagPath'}}],
                              'setStartJointAndEffector': [{'argInfo': {'effectorPath': {'doc': 'The path for the effector',
                                                                                         'type': 'MDagPath'},
                                                                        'jointPath': {'doc': 'The dag path to the joint that will be set ',
                                                                                      'type': 'MDagPath'}},
                                                            'args': [('jointPath',
                                                                      'MDagPath',
                                                                      'in'),
                                                                     ('effectorPath',
                                                                      'MDagPath',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': "\r\nThis method will set the dag path for the starting joint and the end-effector of the handle's joint chain. This method must be used when setting the joints for a handle that are in a different skeletal chain then the current one.",
                                                            'inArgs': ['jointPath',
                                                                       'effectorPath'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'effectorPath': ['const',
                                                                                                '&'],
                                                                               'jointPath': ['const',
                                                                                             '&']},
                                                            'types': {'effectorPath': 'MDagPath',
                                                                      'jointPath': 'MDagPath'}}],
                              'setStickiness': [{'argInfo': {'stickiness': {'doc': 'The stickiness value to be set.',
                                                                            'type': ('MFnIkHandle',
                                                                                     'Stickiness')}},
                                                 'args': [('stickiness',
                                                           ('MFnIkHandle',
                                                            'Stickiness'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nSet the stickiness of this handle. Sticky handles are solved when the skeleton is being manipulated interactively. If a character has sticky feet, the solver will attempt to keep them in the same position as the user moves the character's root. If they were not sticky, they would move along with the root.",
                                                 'inArgs': ['stickiness'],
                                                 'inverse': ('stickiness',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'stickiness': []},
                                                 'types': {'stickiness': ('MFnIkHandle',
                                                                          'Stickiness')}}],
                              'setWeight': [{'argInfo': {'weight': {'doc': 'The weight value to be set',
                                                                    'type': 'double'}},
                                             'args': [('weight',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSpecifies the handles weight in error calculations. The weight only applies when handle goals are in conflict and cannot be solved simultaneously. When this happens, a solution is computed that weights the "distance" from each goal to the solution by the handle\'s weight and attempts to minimize this value. The weight must be >= 0.',
                                             'inArgs': ['weight'],
                                             'inverse': ('weight', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'weight': []},
                                             'types': {'weight': 'double'}}],
                              'solver': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the solver attached to this handle.',
                                          'inArgs': [],
                                          'inverse': ('setSolver', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The solver associated with this handle',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'stickiness': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the stickiness of this handle.',
                                              'inArgs': [],
                                              'inverse': ('setStickiness',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The stickiness value for this handle.',
                                                             'qualifiers': [],
                                                             'type': ('MFnIkHandle',
                                                                      'Stickiness')},
                                              'returnType': ('MFnIkHandle',
                                                             'Stickiness'),
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nFunction set type. \r\n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MFn',
                                                                'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'weight': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGet the handles weight in error calculations. The weight only applies when handle goals are in conflict and cannot be solved simultaneously. When this happens, a solution is computed that weights the "distance" from each goal to the solution by the handle\'s weight and attempts to minimize this value. The weight must be >= 0.',
                                          'inArgs': [],
                                          'inverse': ('setWeight', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The weight value for this handle',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}]},
                  'pymelEnums': {'Stickiness': "Enum('Stickiness', [('stickyOff', 0), ('kStickyOff', 0), ('stickyOn', 1), ('kStickyOn', 1), ('superSticky', 2), ('kSuperSticky', 2)], multiKeys=True)"},
                  'pymelMethods': {'priority': 'getPriority',
                                   'solver': 'getSolver',
                                   'stickiness': 'getStickiness',
                                   'weight': 'getWeight'}},
  'MFnIkJoint': {'enums': {},
                 'invertibles': [('setMaxRotateDampYRange',
                                  'maxRotateDampYRange'),
                                 ('setMinRotateDampXStrength',
                                  'minRotateDampXStrength'),
                                 ('setMinRotateDampYRange',
                                  'minRotateDampYRange'),
                                 ('setMinRotateDampZRange',
                                  'minRotateDampZRange'),
                                 ('setMinRotateDampZStrength',
                                  'minRotateDampZStrength'),
                                 ('setMinRotateDampXRange',
                                  'minRotateDampXRange'),
                                 ('setMinRotateDampYStrength',
                                  'minRotateDampYStrength'),
                                 ('setMaxRotateDampZStrength',
                                  'maxRotateDampZStrength'),
                                 ('setPreferredAngle', 'getPreferredAngle'),
                                 ('setStiffness', 'getStiffness'),
                                 ('setMaxRotateDampXRange',
                                  'maxRotateDampXRange'),
                                 ('setSegmentScale', 'getSegmentScale'),
                                 ('setDegreesOfFreedom',
                                  'getDegreesOfFreedom'),
                                 ('setOrientation', 'getOrientation'),
                                 ('setMaxRotateDampYStrength',
                                  'maxRotateDampYStrength'),
                                 ('setMaxRotateDampXStrength',
                                  'maxRotateDampXStrength'),
                                 ('setMaxRotateDampZRange',
                                  'maxRotateDampZRange'),
                                 ('setScaleOrientation',
                                  'getScaleOrientation')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nClass name. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'create': [{'argInfo': {'parent': {'doc': 'the parent object for this in the dag. A value of NULL specifies the world dag node as parent. ',
                                                                'type': 'MObject'}},
                                         'args': [('parent',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parent': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\nCreate a new joint in a skeleton. In maya, skeletons are defined entirely by DAG hierarchy. So, giving the joint you want to attach to as a parent will add this joint to that skeleton.',
                                         'inArgs': ['parent'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The parent transform of the new joint',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'parent': []},
                                         'types': {'parent': 'MObject'}}],
                             'getDegreesOfFreedom': [{'argInfo': {'freeInX': {'doc': 'the first degree of freedom ',
                                                                              'type': 'bool'},
                                                                  'freeInY': {'doc': 'the second degree of freedom ',
                                                                              'type': 'bool'},
                                                                  'freeInZ': {'doc': 'the third degree of freedom',
                                                                              'type': 'bool'}},
                                                      'args': [('freeInX',
                                                                'bool',
                                                                'out'),
                                                               ('freeInY',
                                                                'bool',
                                                                'out'),
                                                               ('freeInZ',
                                                                'bool',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet degrees of freedom of this joint',
                                                      'inArgs': [],
                                                      'inverse': ('setDegreesOfFreedom',
                                                                  False),
                                                      'outArgs': ['freeInX',
                                                                  'freeInY',
                                                                  'freeInZ'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'freeInX': ['&'],
                                                                         'freeInY': ['&'],
                                                                         'freeInZ': ['&']},
                                                      'types': {'freeInX': 'bool',
                                                                'freeInY': 'bool',
                                                                'freeInZ': 'bool'}}],
                             'getHikJointName': [{'argInfo': {'name': {'doc': 'The name used to identify this joint for HumanIK',
                                                                       'type': 'MString'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nNO SCRIPT SUPPORT. \n',
                                                  'inArgs': [],
                                                  'outArgs': ['name'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'name': ['&']},
                                                  'types': {'name': 'MString'}}],
                             'getOrientation': [{'argInfo': {'quaternion': {'doc': 'the quaternion representing the jointOrient',
                                                                            'type': 'MQuaternion'}},
                                                 'args': [('quaternion',
                                                           'MQuaternion',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nGet the joint orientation. This corresponds to the jointOrient attribute on the joint, which is stored internally as a quaternion. It is different from the rotation orientation defined in the transform node. Modifying the jointOrient changes the coordinate axes, which affects how scaling a joint behaves.',
                                                 'inArgs': [],
                                                 'inverse': ('setOrientation',
                                                             False),
                                                 'outArgs': ['quaternion'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'quaternion': ['&']},
                                                 'types': {'quaternion': 'MQuaternion'}},
                                                {'argInfo': {'rotation': {'doc': 'the euler rotation into which we will store the orientation',
                                                                          'type': 'MEulerRotation'}},
                                                 'args': [('rotation',
                                                           'MEulerRotation',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nGet the orientation of the coordinate axes.',
                                                 'inArgs': [],
                                                 'inverse': ('setOrientation',
                                                             False),
                                                 'outArgs': ['rotation'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'rotation': ['&']},
                                                 'types': {'rotation': 'MEulerRotation'}},
                                                {'argInfo': {'order': {'doc': 'storage for the order to do the rotation in',
                                                                       'type': ('MTransformationMatrix',
                                                                                'RotationOrder')},
                                                             'rotation': {'doc': 'the array into which we will store the angles ',
                                                                          'type': 'double__array3'}},
                                                 'args': [('rotation',
                                                           'double__array3',
                                                           'out'),
                                                          ('order',
                                                           ('MTransformationMatrix',
                                                            'RotationOrder'),
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nGet the orientation of the coordinate axes.',
                                                 'inArgs': [],
                                                 'inverse': ('setOrientation',
                                                             False),
                                                 'outArgs': ['rotation',
                                                             'order'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'order': ['&'],
                                                                    'rotation': []},
                                                 'types': {'order': ('MTransformationMatrix',
                                                                     'RotationOrder'),
                                                           'rotation': 'double__array3'}}],
                             'getPreferredAngle': [{'argInfo': {'rotation': {'doc': 'the array into which we will store the angles',
                                                                             'type': 'double__array3'}},
                                                    'args': [('rotation',
                                                              'double__array3',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet the preferred orientation for this joint (in XYZ order)',
                                                    'inArgs': [],
                                                    'inverse': ('setPreferredAngle',
                                                                False),
                                                    'outArgs': ['rotation'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'rotation': []},
                                                    'types': {'rotation': 'double__array3'}}],
                             'getScaleOrientation': [{'argInfo': {'quaternion': {'doc': 'the quaternion into which we will store the rotate orientation',
                                                                                 'type': 'MQuaternion'}},
                                                      'args': [('quaternion',
                                                                'MQuaternion',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the orientation of the coordinate axes for rotation. This is equivalent to calling the  MFnTransform::rotateOrientation  method, and corresponds to the rotateAxis attribute on the joint node.',
                                                      'inArgs': [],
                                                      'inverse': ('setScaleOrientation',
                                                                  False),
                                                      'outArgs': ['quaternion'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'quaternion': ['&']},
                                                      'types': {'quaternion': 'MQuaternion'}},
                                                     {'argInfo': {'order': {'doc': 'storage for the order to do the rotation in',
                                                                            'type': ('MTransformationMatrix',
                                                                                     'RotationOrder')},
                                                                  'rotation': {'doc': 'the array into which we will store the angles ',
                                                                               'type': 'double__array3'}},
                                                      'args': [('rotation',
                                                                'double__array3',
                                                                'out'),
                                                               ('order',
                                                                ('MTransformationMatrix',
                                                                 'RotationOrder'),
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the orientation of the coordinate axes for rotation. This is equivalent to calling the  MFnTransform::rotateOrientation  method but returns the Euler rotation rather than the quaternion rotation. The matrix equations used to combine the rotateAxis with the other transformation attributes of the joint are described in the description for the  MFnIkJoint  class.',
                                                      'inArgs': [],
                                                      'inverse': ('setScaleOrientation',
                                                                  False),
                                                      'outArgs': ['rotation',
                                                                  'order'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'order': ['&'],
                                                                         'rotation': []},
                                                      'types': {'order': ('MTransformationMatrix',
                                                                          'RotationOrder'),
                                                                'rotation': 'double__array3'}}],
                             'getSegmentScale': [{'argInfo': {'scale': {'doc': 'Storage for the scale values',
                                                                        'type': 'double__array3'}},
                                                  'args': [('scale',
                                                            'double__array3',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nGet the local space scale values for the joint segment (bone). This is equivalent to calling  MFnTransform::getScale .',
                                                  'inArgs': [],
                                                  'inverse': ('setSegmentScale',
                                                              False),
                                                  'outArgs': ['scale'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'scale': []},
                                                  'types': {'scale': 'double__array3'}}],
                             'getStiffness': [{'argInfo': {'stiffness': {'doc': 'storage for the stiffness values',
                                                                         'type': 'double__array3'}},
                                               'args': [('stiffness',
                                                         'double__array3',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nGet the stiffness (from 0 to 100.0) for the joint. The stiffness attribute is used by ik solvers to generate a resistance to a joint motion. The higher the stiffness the less it will rotate. Stiffness works in relative sense: it determines the willingness of this joint to rotate with respect to the other joint in the ik chain.',
                                               'inArgs': [],
                                               'inverse': ('setStiffness',
                                                           False),
                                               'outArgs': ['stiffness'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'stiffness': []},
                                               'types': {'stiffness': 'double__array3'}}],
                             'hikJointName': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nGet the name that the HumanIK solver uses to identify this joint.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The name used to identify this joint for HumanIK',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                             'maxRotateDampXRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the maximum of the damping range in X. This corresponds to the maxRotateDampXRange attribute on the joint.',
                                                      'inArgs': [],
                                                      'inverse': ('setMaxRotateDampXRange',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The maximum of the damping range in X',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                             'maxRotateDampXStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nGet the minimum of the damping strength in X.',
                                                         'inArgs': [],
                                                         'inverse': ('setMaxRotateDampXStrength',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Status code (see below)',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                             'maxRotateDampYRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the maximum of the damping range in Y. This corresponds to the maxRotateDampYRange attribute on the joint.',
                                                      'inArgs': [],
                                                      'inverse': ('setMaxRotateDampYRange',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The maximum of the damping range in Y',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                             'maxRotateDampYStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nGet the minimum of the damping strength in X.',
                                                         'inArgs': [],
                                                         'inverse': ('setMaxRotateDampYStrength',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Status code (see below)',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                             'maxRotateDampZRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the maximum of the damping range in Z. This corresponds to the maxRotateDampZRange attribute on the joint.',
                                                      'inArgs': [],
                                                      'inverse': ('setMaxRotateDampZRange',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The maximum of the damping range in Z',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                             'maxRotateDampZStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nGet the minimum of the damping strength in X.',
                                                         'inArgs': [],
                                                         'inverse': ('setMaxRotateDampZStrength',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Status code (see below)',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                             'minRotateDampXRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the minimum of the damping range in X. This corresponds to the minRotateDampXRange attribute on the joint.',
                                                      'inArgs': [],
                                                      'inverse': ('setMinRotateDampXRange',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The minimum damping range in X',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                             'minRotateDampXStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nGet the minimum of the damping strength in X.',
                                                         'inArgs': [],
                                                         'inverse': ('setMinRotateDampXStrength',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Status code (see below)',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                             'minRotateDampYRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the minimum of the damping range in Y. This corresponds to the minRotateDampYRange attribute on the joint.',
                                                      'inArgs': [],
                                                      'inverse': ('setMinRotateDampYRange',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The minimum damping range in Y',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                             'minRotateDampYStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nGet the minimum of the damping strength in X.',
                                                         'inArgs': [],
                                                         'inverse': ('setMinRotateDampYStrength',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Status code (see below)',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                             'minRotateDampZRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet the minimum of the damping range in Z. This corresponds to the minRotateDampZRange attribute on the joint.',
                                                      'inArgs': [],
                                                      'inverse': ('setMinRotateDampZRange',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The minimum damping range in Z',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                             'minRotateDampZStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nGet the minimum of the damping strength in X.',
                                                         'inArgs': [],
                                                         'inverse': ('setMinRotateDampZStrength',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Status code (see below)',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                             'setDegreesOfFreedom': [{'argInfo': {'freeInX': {'doc': 'the first degree of freedom ',
                                                                              'type': 'bool'},
                                                                  'freeInY': {'doc': 'the second degree of freedom ',
                                                                              'type': 'bool'},
                                                                  'freeInZ': {'doc': 'the third degree of freedom',
                                                                              'type': 'bool'}},
                                                      'args': [('freeInX',
                                                                'bool',
                                                                'in'),
                                                               ('freeInY',
                                                                'bool',
                                                                'in'),
                                                               ('freeInZ',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet the degrees of freedom of this joint by specifying which axes are allowed to rotate.',
                                                      'inArgs': ['freeInX',
                                                                 'freeInY',
                                                                 'freeInZ'],
                                                      'inverse': ('getDegreesOfFreedom',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'freeInX': [],
                                                                         'freeInY': [],
                                                                         'freeInZ': []},
                                                      'types': {'freeInX': 'bool',
                                                                'freeInY': 'bool',
                                                                'freeInZ': 'bool'}}],
                             'setMaxRotateDampXRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSet the maximum of the damping range in X',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('maxRotateDampXRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'angle': []},
                                                         'types': {'angle': 'double'}}],
                             'setMaxRotateDampXStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSet the maximum of the damping strength in X.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('maxRotateDampXStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'angle': []},
                                                            'types': {'angle': 'double'}}],
                             'setMaxRotateDampYRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSet the maximum of the damping range in Y',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('maxRotateDampYRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'angle': []},
                                                         'types': {'angle': 'double'}}],
                             'setMaxRotateDampYStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSet the maximum of the damping strength in Y.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('maxRotateDampYStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'angle': []},
                                                            'types': {'angle': 'double'}}],
                             'setMaxRotateDampZRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSet the maximum of the damping range in Z',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('maxRotateDampZRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'angle': []},
                                                         'types': {'angle': 'double'}}],
                             'setMaxRotateDampZStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSet the maximum of the damping strength in Z.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('maxRotateDampZStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'angle': []},
                                                            'types': {'angle': 'double'}}],
                             'setMinRotateDampXRange': [{'argInfo': {'angle': {'doc': 'The damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSet the minimum of the damping range in X',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('minRotateDampXRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'angle': []},
                                                         'types': {'angle': 'double'}}],
                             'setMinRotateDampXStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSet the maximum of the damping strength in Z.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('minRotateDampXStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'angle': []},
                                                            'types': {'angle': 'double'}}],
                             'setMinRotateDampYRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSet the minimum of the damping range in Y',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('minRotateDampYRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'angle': []},
                                                         'types': {'angle': 'double'}}],
                             'setMinRotateDampYStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSet the maximum of the damping strength in Y.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('minRotateDampYStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'angle': []},
                                                            'types': {'angle': 'double'}}],
                             'setMinRotateDampZRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSet the minimum of the damping range in Z',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('minRotateDampZRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'angle': []},
                                                         'types': {'angle': 'double'}}],
                             'setMinRotateDampZStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSet the minimum of the damping strength in Z.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('minRotateDampZStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'angle': []},
                                                            'types': {'angle': 'double'}}],
                             'setOrientation': [{'argInfo': {'quaternion': {'doc': 'the joint orientation',
                                                                            'type': 'MQuaternion'}},
                                                 'args': [('quaternion',
                                                           'MQuaternion',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSet the jointOrient value. This corresponds to the jointOrient attribute on the joint, which is stored internally as a quaternion. It is different from the rotation orientation defined in the transform node. Modifying the jointOrient changes the coordinate axes, which affects how scaling a joint behaves.',
                                                 'inArgs': ['quaternion'],
                                                 'inverse': ('getOrientation',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'quaternion': ['const',
                                                                                   '&']},
                                                 'types': {'quaternion': 'MQuaternion'}},
                                                {'argInfo': {'rotation': {'doc': 'the orientation',
                                                                          'type': 'MEulerRotation'}},
                                                 'args': [('rotation',
                                                           'MEulerRotation',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSet the orientation of the coordinate axes.',
                                                 'inArgs': ['rotation'],
                                                 'inverse': ('getOrientation',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'rotation': ['const',
                                                                                 '&']},
                                                 'types': {'rotation': 'MEulerRotation'}},
                                                {'argInfo': {'order': {'doc': 'the order to do the rotation in',
                                                                       'type': ('MTransformationMatrix',
                                                                                'RotationOrder')},
                                                             'rotation': {'doc': 'the orientation ',
                                                                          'type': 'double__array3'}},
                                                 'args': [('rotation',
                                                           'double__array3',
                                                           'in'),
                                                          ('order',
                                                           ('MTransformationMatrix',
                                                            'RotationOrder'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSet the orientation of the coordinate axes.',
                                                 'inArgs': ['rotation',
                                                            'order'],
                                                 'inverse': ('getOrientation',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'order': [],
                                                                    'rotation': ['const']},
                                                 'types': {'order': ('MTransformationMatrix',
                                                                     'RotationOrder'),
                                                           'rotation': 'double__array3'}}],
                             'setPreferredAngle': [{'argInfo': {'rotation': {'doc': 'the array into which we will store the angles',
                                                                             'type': 'double__array3'}},
                                                    'args': [('rotation',
                                                              'double__array3',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSet the preferred orientation for this joint (in XYZ order)',
                                                    'inArgs': ['rotation'],
                                                    'inverse': ('getPreferredAngle',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'rotation': ['const']},
                                                    'types': {'rotation': 'double__array3'}}],
                             'setScaleOrientation': [{'argInfo': {'quaternion': {'doc': 'the rotate orientation',
                                                                                 'type': 'MQuaternion'}},
                                                      'args': [(u'quaternion',
                                                                'MQuaternion',
                                                                u'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet the orientation of the coordinate axes for rotation. This is equivalent to calling the  MFnTransform::setRotateOrientation  method, and corresponds to the rotateAxis attribute on the joint node. The matrix equations used to combine the rotateAxis with the other transformation attributes of the joint are described in the description for the  MFnIkJoint  class.',
                                                      'inArgs': [u'quaternion'],
                                                      'inverse': ('getScaleOrientation',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'quaternion': ['const',
                                                                                        '&']},
                                                      'types': {'quaternion': 'MQuaternion'}},
                                                     {'argInfo': {'order': {'doc': 'the order to do the rotation in',
                                                                            'type': ('MTransformationMatrix',
                                                                                     'RotationOrder')},
                                                                  'rotation': {'doc': 'the rotate orientation ',
                                                                               'type': 'double__array3'}},
                                                      'args': [('rotation',
                                                                'double__array3',
                                                                'in'),
                                                               ('order',
                                                                ('MTransformationMatrix',
                                                                 'RotationOrder'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet the orientation of the coordinate axes for rotation. This is equivalent to calling the  MFnTransform::setRotateOrientation  method, and corresponds to the rotateAxis attribute on the joint node. The matrix equations used to combine the rotateAxis with the other transformation attributes of the joint are described in the description for the  MFnIkJoint  class.',
                                                      'inArgs': ['rotation',
                                                                 'order'],
                                                      'inverse': ('getScaleOrientation',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'order': [],
                                                                         'rotation': ['const']},
                                                      'types': {'order': ('MTransformationMatrix',
                                                                          'RotationOrder'),
                                                                'rotation': 'double__array3'}}],
                             'setSegmentScale': [{'argInfo': {'scale': {'doc': 'the new scale values to set',
                                                                        'type': 'double__array3'}},
                                                  'args': [('scale',
                                                            'double__array3',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nSet the local space scale values for the joint segment (bone). This is equivalent to calling Ttransform::setScale.',
                                                  'inArgs': ['scale'],
                                                  'inverse': ('getSegmentScale',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'scale': ['const']},
                                                  'types': {'scale': 'double__array3'}}],
                             'setStiffness': [{'argInfo': {'stiffness': {'doc': 'the X, Y, and Z stiffness values',
                                                                         'type': 'double__array3'}},
                                               'args': [('stiffness',
                                                         'double__array3',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nSet the stiffness (from 0 to 100.0) for the joint. The stiffness attribute is used by ik solvers to generate a resistance to a joint motion. The higher the stiffness the less it will rotate. Stiffness works in relative sense: it determines the willingness of this joint to rotate with respect to the other joint in the ik chain.',
                                               'inArgs': ['stiffness'],
                                               'inverse': ('getStiffness',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'stiffness': ['const']},
                                               'types': {'stiffness': 'double__array3'}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nFunction set type. \n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': ('MFn',
                                                               'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'maxRotateDampXRange': 'getMaxRotateDampXRange',
                                  'maxRotateDampXStrength': 'getMaxRotateDampXStrength',
                                  'maxRotateDampYRange': 'getMaxRotateDampYRange',
                                  'maxRotateDampYStrength': 'getMaxRotateDampYStrength',
                                  'maxRotateDampZRange': 'getMaxRotateDampZRange',
                                  'maxRotateDampZStrength': 'getMaxRotateDampZStrength',
                                  'minRotateDampXRange': 'getMinRotateDampXRange',
                                  'minRotateDampXStrength': 'getMinRotateDampXStrength',
                                  'minRotateDampYRange': 'getMinRotateDampYRange',
                                  'minRotateDampYStrength': 'getMinRotateDampYStrength',
                                  'minRotateDampZRange': 'getMinRotateDampZRange',
                                  'minRotateDampZStrength': 'getMinRotateDampZStrength'}},
  'MFnIkSolver': {'enums': {},
                  'invertibles': [('setTolerance', 'tolerance'),
                                  ('setMaxIterations', 'maxIterations')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nClass name. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'maxIterations': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the maximum number of iterations used when solving.',
                                                 'inArgs': [],
                                                 'inverse': ('setMaxIterations',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The maximum number of iterations used by this solver when solving',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                              'setMaxIterations': [{'argInfo': {'maxIters': {'doc': 'the new value for the maximum number of iterations for the solver',
                                                                             'type': 'uint'}},
                                                    'args': [('maxIters',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets the maximum number of iterations used when solving.',
                                                    'inArgs': ['maxIters'],
                                                    'inverse': ('maxIterations',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'maxIters': ['unsigned']},
                                                    'types': {'maxIters': 'uint'}}],
                              'setTolerance': [{'argInfo': {'tolerance': {'doc': 'The tolerance value to be set',
                                                                          'type': 'double'}},
                                                'args': [('tolerance',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSets the tolerance used when solving.',
                                                'inArgs': ['tolerance'],
                                                'inverse': ('tolerance',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'tolerance': []},
                                                'types': {'tolerance': 'double'}}],
                              'tolerance': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the tolerance used when solving.',
                                             'inArgs': [],
                                             'inverse': ('setTolerance',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The tolerance value for this solver',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nFunction set type. \n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MFn',
                                                                'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'maxIterations': 'getMaxIterations',
                                   'tolerance': 'getTolerance'}},
  'MFnImageSource': {'enums': {},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nClass name. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'getImageName': [{'argInfo': {'bufferName': {'doc': 'Name of the buffer containing the image, used with OpenEXR files. ',
                                                                              'type': 'MString'},
                                                               'camera': {'doc': 'Parent transform of the camera used to render the scene. ',
                                                                          'type': 'MObject'},
                                                               'frameNumber': {'doc': 'Desired frame in image sequence. ',
                                                                               'type': 'double'},
                                                               'pathType': {'doc': 'Project relative, full, or temporary directory. ',
                                                                            'type': ('MCommonRenderSettingsData',
                                                                                     'MpathType')},
                                                               'renderLayer': {'doc': 'Render layer used to render scene. ',
                                                                               'type': 'MObject'},
                                                               'sceneName': {'doc': 'Scene for which image was rendered. ',
                                                                             'type': 'MString'}},
                                                   'args': [('pathType',
                                                             ('MCommonRenderSettingsData',
                                                              'MpathType'),
                                                             'in'),
                                                            ('frameNumber',
                                                             'double',
                                                             'in'),
                                                            ('sceneName',
                                                             'MString',
                                                             'in'),
                                                            ('camera',
                                                             'MObject',
                                                             'in'),
                                                            ('renderLayer',
                                                             'MObject',
                                                             'in'),
                                                            ('bufferName',
                                                             'MString',
                                                             'out')],
                                                   'defaults': {'bufferName': None},
                                                   'deprecated': False,
                                                   'doc': '\nReturn image path associated with this image source.',
                                                   'inArgs': ['pathType',
                                                              'frameNumber',
                                                              'sceneName',
                                                              'camera',
                                                              'renderLayer'],
                                                   'outArgs': ['bufferName'],
                                                   'returnInfo': {'doc': 'Path to image file. ',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'bufferName': ['*'],
                                                                      'camera': ['const'],
                                                                      'frameNumber': [],
                                                                      'pathType': [],
                                                                      'renderLayer': ['const'],
                                                                      'sceneName': ['const',
                                                                                    '&']},
                                                   'types': {'bufferName': 'MString',
                                                             'camera': 'MObject',
                                                             'frameNumber': 'double',
                                                             'pathType': ('MCommonRenderSettingsData',
                                                                          'MpathType'),
                                                             'renderLayer': 'MObject',
                                                             'sceneName': 'MString'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnInstancer': {'enums': {},
                   'methods': {'allInstances': [{'argInfo': {'matrices': {'doc': 'For each particle p, matrices[p] receives the matrix that the instancer applies to the paths instanced under that particle to generate the final instance transformations. ',
                                                                          'type': 'MMatrixArray'},
                                                             'particlePathStartIndices': {'doc': 'Receives indices into the pathIndices array indicating where the block of indices for each particle begins. The size of this array is always one more than the number of particles in the system. For particle p, the number of paths instanced under that particle is particlePathStartIndices[p+1]-particlePathStartIndices[p]. If this number is 0, then no visible paths are instanced under that particle. So, the set pathIndices[particlePathStartIndices[p]...particlePathStartIndices[p+1]-1] gives the indices into the paths array of the visible paths instanced under particle p. ',
                                                                                          'type': 'MIntArray'},
                                                             'pathIndices': {'doc': 'Receives indices into the paths array describing the visible paths instanced under each particle. The array is a sequence of variable-sized blocks, one per particle (since each particle in the system can instance a different number of paths). The particlePathStartIndices array determines where in this array to find the path indices for a particular particle.',
                                                                             'type': 'MIntArray'},
                                                             'paths': {'doc': 'Receives the unique set of paths instanced by any particle in the system. ',
                                                                       'type': 'MDagPathArray'}},
                                                 'args': [('paths',
                                                           'MDagPathArray',
                                                           'out'),
                                                          ('matrices',
                                                           'MMatrixArray',
                                                           'out'),
                                                          ('particlePathStartIndices',
                                                           'MIntArray',
                                                           'out'),
                                                          ('pathIndices',
                                                           'MIntArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns information about all instances generated by a particular particle instancer node. Since many particles will typically instance similar sets of paths, the information is returned in a compact representation. An array of paths is returned, representing the unique set of paths that are instanced by any particle in the system. For each particle, the routine returns a set of indices into this path array to illustrate the paths instanced at that particle. The index arrays for all particles are concatenated together, so a "start index" array is used to indicate which is the first entry in the index array for each particle. For each particle, the routine also returns the transformation matrix applied to that particle\'s instanced paths to generate the final particle instance transformations.',
                                                 'inArgs': [],
                                                 'outArgs': ['paths',
                                                             'matrices',
                                                             'particlePathStartIndices',
                                                             'pathIndices'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'matrices': ['&'],
                                                                    'particlePathStartIndices': ['&'],
                                                                    'pathIndices': ['&'],
                                                                    'paths': ['&']},
                                                 'types': {'matrices': 'MMatrixArray',
                                                           'particlePathStartIndices': 'MIntArray',
                                                           'pathIndices': 'MIntArray',
                                                           'paths': 'MDagPathArray'}}],
                               'instancesForParticle': [{'argInfo': {'instancerMatrix': {'doc': "The transformation matrix that the instancer applies to the instanced paths to produce the final particle-instanced geometry. The final world matrix of each instance can be constructed by premultiplying the path's inclusive world matrix by this matrix. ",
                                                                                         'type': 'MMatrix'},
                                                                     'p': {'doc': 'The index of the particle being queried. ',
                                                                           'type': 'int'},
                                                                     'paths': {'doc': 'Visible DAG paths generated by particle p ',
                                                                               'type': 'MDagPathArray'}},
                                                         'args': [('p',
                                                                   'int',
                                                                   'in'),
                                                                  ('paths',
                                                                   'MDagPathArray',
                                                                   'out'),
                                                                  ('instancerMatrix',
                                                                   'MMatrix',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the DAG paths and instancer matrix for all instances generated by a specified particle',
                                                         'inArgs': ['p'],
                                                         'outArgs': ['paths',
                                                                     'instancerMatrix'],
                                                         'returnInfo': {'doc': 'The number of visible paths instanced for the given particle. It is possible for no paths to be instanced for a particular particle. Note that in order to use this method, the MDagPath must be used in the constructor. ',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'instancerMatrix': ['&'],
                                                                            'p': [],
                                                                            'paths': ['&']},
                                                         'types': {'instancerMatrix': 'MMatrix',
                                                                   'p': 'int',
                                                                   'paths': 'MDagPathArray'}}],
                               'particleCount': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the number of particles feeding the active instancer',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {}},
  'MFnIntArrayData': {'enums': {},
                      'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the integer to extract',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nExtract the indicated integer from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return an integer containing zero.',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The indicated integer ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'index': ['unsigned']},
                                                   'types': {'index': 'uint'}},
                                                  {'argInfo': {'index': {'doc': 'the index of the integer to extract',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nNO SCRIPT SUPPORT. \n',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The indicated integer ',
                                                                  'qualifiers': ['&'],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                                  'array': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturn an  MIntArray  containing the integer array currently operated upon by the function set. The  MIntArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A copy of the MIntArray held in this instance ',
                                                            'qualifiers': [],
                                                            'type': 'MIntArray'},
                                             'returnType': 'MIntArray',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nClass name. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'copyTo': [{'argInfo': {'dest': {'doc': 'the MIntArray to populate',
                                                                   'type': 'MIntArray'}},
                                              'args': [('dest',
                                                        'MIntArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nCopy all the integers in the instance into the given  MIntArray .',
                                              'inArgs': [],
                                              'outArgs': ['dest'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'dest': ['&']},
                                              'types': {'dest': 'MIntArray'}}],
                                  'create': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nCreate a new  MObject , attach it to this instance, and initialize it to contain no ints.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The newly created MObject ',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}},
                                             {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                  'type': 'MIntArray'}},
                                              'args': [('arr',
                                                        'MIntArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nCreate a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MIntArray .',
                                              'inArgs': ['arr'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The newly created MObject ',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'arr': ['const',
                                                                         '&']},
                                              'types': {'arr': 'MIntArray'}}],
                                  'length': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturn the number of integers in the instance.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The number of integers in the instance ',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                  'set': [{'argInfo': {'element': {'doc': 'the element ',
                                                                   'type': 'int'},
                                                       'index': {'doc': 'the index of the integer to extract',
                                                                 'type': 'uint'}},
                                           'args': [('element',
                                                     'int',
                                                     'in'),
                                                    ('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSet the integer element at the specified index of this array.',
                                           'inArgs': ['element', 'index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': [],
                                                              'index': ['unsigned']},
                                           'types': {'element': 'int',
                                                     'index': 'uint'}},
                                          {'argInfo': {'array': {'doc': 'the MIntArray containing the data to set into this instance',
                                                                 'type': 'MIntArray'}},
                                           'args': [('array',
                                                     'MIntArray',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSet the instance to contain the integers defined in the given  MIntArray .',
                                           'inArgs': ['array'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'array': ['const',
                                                                        '&']},
                                           'types': {'array': 'MIntArray'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFunction set type. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {}},
  'MFnKeyframeDelta': {'enums': {},
                       'methods': {'keyIndex': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nThe index of this key on the animation curve.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'An unsigned int representing the position of the key on the curve.',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                   'paramCurve': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturn the Animation Curve  MObject  that this key belongs to.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'A MObject, readable by MFnAnimCurve.',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nFunction set type. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                       'pymelEnums': {}},
  'MFnKeyframeDeltaAddRemove': {'enums': {'DeltaType': {'valueDocs': {'added': 'Key added.',
                                                                      'kAdded': 'Key added.',
                                                                      'kRemoved': 'Key removed.',
                                                                      'kReplaced': 'Key replaced.',
                                                                      'removed': 'Key removed.',
                                                                      'replaced': 'Key replaced.'},
                                                        'values': "Enum('DeltaType', {'kAdded': 0, 'kRemoved': 1, 'kReplaced': 2})"}},
                                'methods': {'className': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nClass name. \n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'deltaType': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nIndicates the type of change that this class instance represents.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' kAdded - a key has been added.  kRemoved - a key has been removed.  ',
                                                                          'qualifiers': [],
                                                                          'type': ('MFnKeyframeDeltaAddRemove',
                                                                                   'DeltaType')},
                                                           'returnType': ('MFnKeyframeDeltaAddRemove',
                                                                          'DeltaType'),
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                            'keyIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nThe index of this key on the animation curve.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'An unsigned int representing the position of the key on the curve.',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                            'replacedValue': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nThe value of the key that was replaced. This method is only applicable to the kReplaced operation. Otherwise it will return 0.',
                                                               'inArgs': [],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'A double value',
                                                                              'qualifiers': [],
                                                                              'type': 'double'},
                                                               'returnType': 'double',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                                               'types': {}}],
                                            'time': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nThe time value of the key that was added or removed.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A MTime value of the added/removed key.',
                                                                     'qualifiers': [],
                                                                     'type': 'MTime'},
                                                      'returnType': 'MTime',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nFunction set type. \n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                            'value': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nThe value of the key that was added or removed.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A double value',
                                                                      'qualifiers': [],
                                                                      'type': 'double'},
                                                       'returnType': 'double',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}]},
                                'pymelEnums': {'DeltaType': "Enum('DeltaType', [('added', 0), ('kAdded', 0), ('removed', 1), ('kRemoved', 1), ('replaced', 2), ('kReplaced', 2)], multiKeys=True)"}},
  'MFnKeyframeDeltaBlockAddRemove': {'enums': {'DeltaType': {'valueDocs': {'added': 'Keys were added.',
                                                                           'kAdded': 'Keys were added.',
                                                                           'kRemoved': 'Keys were removed.',
                                                                           'removed': 'Keys were removed.'},
                                                             'values': "Enum('DeltaType', {'kAdded': 0, 'kRemoved': 1})"}},
                                     'methods': {'className': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nClass name. \n',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': ['*'],
                                                                               'type': 'char'},
                                                                'returnType': 'char',
                                                                'static': False,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                                                 'deltaType': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nIndicates the type of change, i.e. keys added or removed, that this class instance represents.',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': ' kAdded - a block of keys were added.  kRemoved - a block of keys were removed.  ',
                                                                               'qualifiers': [],
                                                                               'type': ('MFnKeyframeDeltaBlockAddRemove',
                                                                                        'DeltaType')},
                                                                'returnType': ('MFnKeyframeDeltaBlockAddRemove',
                                                                               'DeltaType'),
                                                                'static': False,
                                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                                'types': {}}],
                                                 'endTime': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nReturns an  MTime  value indicating the endTime of the add/remove.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'An MTime value indicating the end of the add/remove.',
                                                                             'qualifiers': [],
                                                                             'type': 'MTime'},
                                                              'returnType': 'MTime',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                                 'getTimes': [{'argInfo': {'times': {'doc': 'MTimeArray to store all time values. ',
                                                                                     'type': 'MTimeArray'}},
                                                               'args': [('times',
                                                                         'MTimeArray',
                                                                         'out')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nReturns the times of all keys involved in the group add or remove.',
                                                               'inArgs': [],
                                                               'outArgs': ['times'],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'times': ['&']},
                                                               'types': {'times': 'MTimeArray'}}],
                                                 'getValues': [{'argInfo': {'values': {'doc': 'MDoubleArray to store values. ',
                                                                                       'type': 'MDoubleArray'}},
                                                                'args': [('values',
                                                                          'MDoubleArray',
                                                                          'out')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nReturns the values of all keys involved in the group add or remove.',
                                                                'inArgs': [],
                                                                'outArgs': ['values'],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'values': ['&']},
                                                                'types': {'values': 'MDoubleArray'}}],
                                                 'numKeys': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nTotal number of keys involved in this add or remove operation.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': 'int'},
                                                              'returnType': 'int',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                                 'startTime': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nAn  MTime  value indicating the start time of the add/remove.',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'An MTime value.',
                                                                               'qualifiers': [],
                                                                               'type': 'MTime'},
                                                                'returnType': 'MTime',
                                                                'static': False,
                                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                                'types': {}}],
                                                 'type': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nFunction set type. \n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': ('MFn',
                                                                                   'Type')},
                                                           'returnType': ('MFn',
                                                                          'Type'),
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}]},
                                     'pymelEnums': {'DeltaType': "Enum('DeltaType', [('added', 0), ('kAdded', 0), ('removed', 1), ('kRemoved', 1)], multiKeys=True)"}},
  'MFnKeyframeDeltaBreakdown': {'enums': {},
                                'methods': {'className': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nClass name. \n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'isBreakdown': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nReturns the current breakdown state of the key. It will return true if the key was converted to a breakdown key.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': "true or false depending on the key's breakdown state.",
                                                                            'qualifiers': [],
                                                                            'type': 'bool'},
                                                             'returnType': 'bool',
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                                             'types': {}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nFunction set type. \n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                            'wasBreakdown': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nReturns the previous breakdown state of the key. It will return false if the key was converted to a breakdown key.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': "true or false depending on the key's breakdown state.",
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}]},
                                'pymelEnums': {}},
  'MFnKeyframeDeltaInfType': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nClass name. \n',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'currentInfinityType': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nThe current infinity type.',
                                                                   'inArgs': [],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'The current InfinityType for the curve',
                                                                                  'qualifiers': [],
                                                                                  'type': ('MFnAnimCurve',
                                                                                           'InfinityType')},
                                                                   'returnType': ('MFnAnimCurve',
                                                                                  'InfinityType'),
                                                                   'static': False,
                                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                                   'types': {}}],
                                          'isPreInfinity': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nThis class can describe changes to both the pre-infinity and post-infinity this method allows the API user to figure out which type this class represents.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'true if this class encapsulates changes to the pre-infinity type.',
                                                                            'qualifiers': [],
                                                                            'type': 'bool'},
                                                             'returnType': 'bool',
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                                             'types': {}}],
                                          'previousInfinityType': [{'argInfo': {},
                                                                    'args': [],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\nThe previous infinity type.',
                                                                    'inArgs': [],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'The previous infinityType for the curve.',
                                                                                   'qualifiers': [],
                                                                                   'type': ('MFnAnimCurve',
                                                                                            'InfinityType')},
                                                                    'returnType': ('MFnAnimCurve',
                                                                                   'InfinityType'),
                                                                    'static': False,
                                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                                    'types': {}}],
                                          'type': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nFunction set type. \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': ('MFn',
                                                                            'Type')},
                                                    'returnType': ('MFn',
                                                                   'Type'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                              'pymelEnums': {}},
  'MFnKeyframeDeltaMove': {'enums': {},
                           'methods': {'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nClass name. \n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'currentTime': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nThe current/current time value.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'A MTime containing the current time of this key.',
                                                                       'qualifiers': [],
                                                                       'type': 'MTime'},
                                                        'returnType': 'MTime',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                       'currentValue': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nThe current value of the key. The value corresponds to the units of the animation curve.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A double representing the current value of the key.',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                       'keyIndex': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nThe current index value of this key.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'An unsigned value representing the current index of this key on the curve.',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                       'previousIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nThe previous index value of this key. If a key has been moved over another key then you can use this previous index to figure out where the key was moved from.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'An unsigned value representing the previous index of this key on the curve.',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                       'previousTime': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nThe previous time value of this key.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A MTime containing the previous time of this key.',
                                                                        'qualifiers': [],
                                                                        'type': 'MTime'},
                                                         'returnType': 'MTime',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                       'previousValue': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nThe previous value of the key prior to the change. The value corresponds to the units of the animation curve.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'A double representing the previous value of the key.',
                                                                         'qualifiers': [],
                                                                         'type': 'double'},
                                                          'returnType': 'double',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nFunction set type. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MFn',
                                                                         'Type')},
                                                 'returnType': ('MFn',
                                                                'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                           'pymelEnums': {}},
  'MFnKeyframeDeltaScale': {'enums': {},
                            'methods': {'className': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nClass name. \n',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'char'},
                                                       'returnType': 'char',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        'currentEndTime': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nThe current end time.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'An MTime value',
                                                                           'qualifiers': [],
                                                                           'type': 'MTime'},
                                                            'returnType': 'MTime',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                        'currentStartTime': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nThe current scale time (after scaling has been performed).',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'An MTime value',
                                                                             'qualifiers': [],
                                                                             'type': 'MTime'},
                                                              'returnType': 'MTime',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                        'endTime': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nThe end time of the scaling block.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'An MTime value',
                                                                    'qualifiers': [],
                                                                    'type': 'MTime'},
                                                     'returnType': 'MTime',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                        'pivotTime': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nThe pivot point of the scale (in time).',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'An MTime value',
                                                                      'qualifiers': [],
                                                                      'type': 'MTime'},
                                                       'returnType': 'MTime',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                        'startTime': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nThe start time of the scaling block.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'An MTime value',
                                                                      'qualifiers': [],
                                                                      'type': 'MTime'},
                                                       'returnType': 'MTime',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                        'type': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nFunction set type. \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': ('MFn',
                                                                          'Type')},
                                                  'returnType': ('MFn',
                                                                 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                            'pymelEnums': {}},
  'MFnKeyframeDeltaTangent': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nClass name. \n',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'currentTangentType': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nReturns the current tangent type that the key represents.',
                                                                  'inArgs': [],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'The current tangent type.',
                                                                                 'qualifiers': [],
                                                                                 'type': ('MFnAnimCurve',
                                                                                          'TangentType')},
                                                                  'returnType': ('MFnAnimCurve',
                                                                                 'TangentType'),
                                                                  'static': False,
                                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                                  'types': {}}],
                                          'getCurrentPosition': [{'argInfo': {'x': {'doc': 'The x component of the position. ',
                                                                                    'type': ('MFnAnimCurve',
                                                                                             'TangentValue')},
                                                                              'y': {'doc': 'The y component of the position.',
                                                                                    'type': ('MFnAnimCurve',
                                                                                             'TangentValue')}},
                                                                  'args': [('x',
                                                                            ('MFnAnimCurve',
                                                                             'TangentValue'),
                                                                            'out'),
                                                                           ('y',
                                                                            ('MFnAnimCurve',
                                                                             'TangentValue'),
                                                                            'out')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nGet the values of the current time/value position of the tangent for this key.',
                                                                  'inArgs': [],
                                                                  'outArgs': ['x',
                                                                              'y'],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'x': ['&'],
                                                                                     'y': ['&']},
                                                                  'types': {'x': ('MFnAnimCurve',
                                                                                  'TangentValue'),
                                                                            'y': ('MFnAnimCurve',
                                                                                  'TangentValue')}}],
                                          'getPreviousPosition': [{'argInfo': {'x': {'doc': 'The x component of the position. ',
                                                                                     'type': ('MFnAnimCurve',
                                                                                              'TangentValue')},
                                                                               'y': {'doc': 'The y component of the position.',
                                                                                     'type': ('MFnAnimCurve',
                                                                                              'TangentValue')}},
                                                                   'args': [('x',
                                                                             ('MFnAnimCurve',
                                                                              'TangentValue'),
                                                                             'out'),
                                                                            ('y',
                                                                             ('MFnAnimCurve',
                                                                              'TangentValue'),
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nGet the values of the previous time/value position of the tangent for this key.',
                                                                   'inArgs': [],
                                                                   'outArgs': ['x',
                                                                               'y'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'x': ['&'],
                                                                                      'y': ['&']},
                                                                   'types': {'x': ('MFnAnimCurve',
                                                                                   'TangentValue'),
                                                                             'y': ('MFnAnimCurve',
                                                                                   'TangentValue')}}],
                                          'isInTangent': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': "\nKey's have two tangents, in-bound and out-bound. A MFnKeyframeTangent object can created once for each tangent. Use this method to determine which tangent was modified.",
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' true if the incoming tangent was modified.  false if the outgoing tangent was modified.  ',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                          'previousTangentType': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nReturns the previous tangent type.',
                                                                   'inArgs': [],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'The previous tangent type.',
                                                                                  'qualifiers': [],
                                                                                  'type': ('MFnAnimCurve',
                                                                                           'TangentType')},
                                                                   'returnType': ('MFnAnimCurve',
                                                                                  'TangentType'),
                                                                   'static': False,
                                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                                   'types': {}}],
                                          'type': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nFunction set type. \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': ('MFn',
                                                                            'Type')},
                                                    'returnType': ('MFn',
                                                                   'Type'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                              'pymelEnums': {}},
  'MFnKeyframeDeltaWeighted': {'enums': {},
                               'methods': {'className': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nClass name. \n',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': ['*'],
                                                                         'type': 'char'},
                                                          'returnType': 'char',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                           'type': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nFunction set type. \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': ('MFn',
                                                                             'Type')},
                                                     'returnType': ('MFn',
                                                                    'Type'),
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                           'wasWeighted': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturns true if the key had weighted tangent, but it is not currently.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': "true or false depending on the key's weight status.",
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}]},
                               'pymelEnums': {}},
  'MFnLambertShader': {'enums': {},
                       'invertibles': [('setAmbientColor', 'ambientColor'),
                                       ('setHideSource', 'hideSource'),
                                       ('setRefractiveIndex',
                                        'refractiveIndex'),
                                       ('setGlowIntensity',
                                        'glowIntensity'),
                                       ('setDiffuseCoeff', 'diffuseCoeff'),
                                       ('setIncandescence',
                                        'incandescence'),
                                       ('setTransparency', 'transparency'),
                                       ('setRtRefractedColor',
                                        'rtRefractedColor'),
                                       ('setRefractedRayDepthLimit',
                                        'refractedRayDepthLimit'),
                                       ('setColor', 'color'),
                                       ('setTranslucenceCoeff',
                                        'translucenceCoeff')],
                       'methods': {'ambientColor': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the value of the "ambientColor" attribute of a shader node. This attribute represents the ambient color of the shader.',
                                                     'inArgs': [],
                                                     'inverse': ('setAmbientColor',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "ambientColor" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'MColor'},
                                                     'returnType': 'MColor',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nClass name. \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'color': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nRetrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.',
                                              'inArgs': [],
                                              'inverse': ('setColor',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the "color" attribute of the shader node.',
                                                             'qualifiers': [],
                                                             'type': 'MColor'},
                                              'returnType': 'MColor',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                   'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not the new node will be connected to the shader classification node. ',
                                                                         'type': 'bool'}},
                                               'args': [('UIvisible',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'UIvisible': True},
                                               'deprecated': False,
                                               'doc': '\nCreates a new lambert shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.',
                                               'inArgs': ['UIvisible'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'UIvisible': []},
                                               'types': {'UIvisible': 'bool'}}],
                                   'diffuseCoeff': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the value of the "diffuseCoeff" attribute of a lambert shader node. This attribute represents the diffuse reflectivity of the shader.',
                                                     'inArgs': [],
                                                     'inverse': ('setDiffuseCoeff',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "diffuseCoeff" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'glowIntensity': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nRetrieves the value of the "glowIntensity" attribute of a shader node. This attribute represents the constant multplier applied to the glow color of the shader.',
                                                      'inArgs': [],
                                                      'inverse': ('setGlowIntensity',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The value of the "glowIntensity" attribute of the shader node.',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'hideSource': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nRetrieves the value of the "hideSource" attribute of a shader node. This attribute determines whether or not the computed surface color is used in the shading computation. If hideSource is true, then only the computed shader glow color will be used. Otherwise, both the glow and surface colors will be used.',
                                                   'inArgs': [],
                                                   'inverse': ('setHideSource',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The value of the "hideSource" attribute of the shader node.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                   'incandescence': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nRetrieves the value of the "incandescence" attribute of a shader node. This attribute represents the incandescence of the shader.',
                                                      'inArgs': [],
                                                      'inverse': ('setIncandescence',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The value of the "incandescence" attribute of the shader node.',
                                                                     'qualifiers': [],
                                                                     'type': 'MColor'},
                                                      'returnType': 'MColor',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'refractedRayDepthLimit': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nRetrieves the value of the "refractedRayDepthLimit" attribute of a lambert shader node. This attribute represents the maximum refracted ray depth used in the shading calculation.',
                                                               'inArgs': [],
                                                               'inverse': ('setRefractedRayDepthLimit',
                                                                           False),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The value of the "refractedRayDepthLimit" attribute of the node.',
                                                                              'qualifiers': [],
                                                                              'type': 'short'},
                                                               'returnType': 'short',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                                               'types': {}}],
                                   'refractiveIndex': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieves the value of the "refractiveIndex" attribute of a lambert shader node. This attribute represents the refractive index of the shader.',
                                                        'inArgs': [],
                                                        'inverse': ('setRefractiveIndex',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "refractiveIndex" attribute of the shader node.',
                                                                       'qualifiers': [],
                                                                       'type': 'float'},
                                                        'returnType': 'float',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                   'rtRefractedColor': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nRetrieves the value of the "rtRefractedColor" attribute of a shader node. This attribute determines whether the shader uses the value of the "refractedColor" attribute for the refracted color or calculated the refracted color itself.',
                                                         'inArgs': [],
                                                         'inverse': ('setRtRefractedColor',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The value of the "rtRefractedColor" attribute of the shader node.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                   'setAmbientColor': [{'argInfo': {'ambient_color': {'doc': 'value to which the attribute will be set.',
                                                                                      'type': 'MColor'}},
                                                        'args': [('ambient_color',
                                                                  'MColor',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the value of the "ambientColor" attribute of a shader node.',
                                                        'inArgs': ['ambient_color'],
                                                        'inverse': ('ambientColor',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'ambient_color': ['const',
                                                                                             '&']},
                                                        'types': {'ambient_color': 'MColor'}}],
                                   'setColor': [{'argInfo': {'col': {'doc': 'value to which the attribute will be set.',
                                                                     'type': 'MColor'}},
                                                 'args': [('col',
                                                           'MColor',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSets the value of the "color" attribute of a shader node.',
                                                 'inArgs': ['col'],
                                                 'inverse': ('color',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'col': ['const',
                                                                            '&']},
                                                 'types': {'col': 'MColor'}}],
                                   'setDiffuseCoeff': [{'argInfo': {'diffuse_coeff': {'doc': 'value to which the attribute will be set.',
                                                                                      'type': 'float'}},
                                                        'args': [('diffuse_coeff',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the value of the "diffuseCoeff" attribute of a shader node.',
                                                        'inArgs': ['diffuse_coeff'],
                                                        'inverse': ('diffuseCoeff',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'diffuse_coeff': ['const',
                                                                                             '&']},
                                                        'types': {'diffuse_coeff': 'float'}}],
                                   'setGlowIntensity': [{'argInfo': {'glow_intensity': {'doc': 'value to which the attribute will be set.',
                                                                                        'type': 'float'}},
                                                         'args': [('glow_intensity',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the value of the "glowIntensity" attribute of a shader node.',
                                                         'inArgs': ['glow_intensity'],
                                                         'inverse': ('glowIntensity',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'glow_intensity': ['const',
                                                                                               '&']},
                                                         'types': {'glow_intensity': 'float'}}],
                                   'setHideSource': [{'argInfo': {'hide_source': {'doc': 'value to which the attribute will be set.',
                                                                                  'type': 'bool'}},
                                                      'args': [('hide_source',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets the value of the "hideSource" attribute of a shader node.',
                                                      'inArgs': ['hide_source'],
                                                      'inverse': ('hideSource',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'hide_source': ['const',
                                                                                         '&']},
                                                      'types': {'hide_source': 'bool'}}],
                                   'setIncandescence': [{'argInfo': {'incand': {'doc': 'value to which the attribute will be set.',
                                                                                'type': 'MColor'}},
                                                         'args': [('incand',
                                                                   'MColor',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the value of the "incandescence" attribute of a shader node.',
                                                         'inArgs': ['incand'],
                                                         'inverse': ('incandescence',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'incand': ['const',
                                                                                       '&']},
                                                         'types': {'incand': 'MColor'}}],
                                   'setRefractedRayDepthLimit': [{'argInfo': {'refracted_ray_depth_limit': {'doc': 'value to which the attribute will be set.',
                                                                                                            'type': 'short'}},
                                                                  'args': [('refracted_ray_depth_limit',
                                                                            'short',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nSets the value of the "refractedRayDepthLimit" attribute of a lambert shader node.',
                                                                  'inArgs': ['refracted_ray_depth_limit'],
                                                                  'inverse': ('refractedRayDepthLimit',
                                                                              True),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'refracted_ray_depth_limit': ['const',
                                                                                                                   '&']},
                                                                  'types': {'refracted_ray_depth_limit': 'short'}}],
                                   'setRefractiveIndex': [{'argInfo': {'refractive_index': {'doc': 'value to which the attribute will be set.',
                                                                                            'type': 'float'}},
                                                           'args': [('refractive_index',
                                                                     'float',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the value of the "refractiveIndex" attribute of a shader node.',
                                                           'inArgs': ['refractive_index'],
                                                           'inverse': ('refractiveIndex',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'refractive_index': ['const',
                                                                                                   '&']},
                                                           'types': {'refractive_index': 'float'}}],
                                   'setRtRefractedColor': [{'argInfo': {'rt_refracted_color': {'doc': 'value to which the attribute will be set.',
                                                                                               'type': 'bool'}},
                                                            'args': [('rt_refracted_color',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSets the value of the "rtRefractedColor" attribute of a shader node.',
                                                            'inArgs': ['rt_refracted_color'],
                                                            'inverse': ('rtRefractedColor',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'rt_refracted_color': ['const',
                                                                                                      '&']},
                                                            'types': {'rt_refracted_color': 'bool'}}],
                                   'setTranslucenceCoeff': [{'argInfo': {'translucence_coeff': {'doc': 'value to which the attribute will be set.',
                                                                                                'type': 'float'}},
                                                             'args': [('translucence_coeff',
                                                                       'float',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nSets the value of the "translucenceCoeff" attribute of a shader node.',
                                                             'inArgs': ['translucence_coeff'],
                                                             'inverse': ('translucenceCoeff',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'translucence_coeff': ['const',
                                                                                                       '&']},
                                                             'types': {'translucence_coeff': 'float'}}],
                                   'setTransparency': [{'argInfo': {'transp': {'doc': 'value to which the attribute will be set.',
                                                                               'type': 'MColor'}},
                                                        'args': [('transp',
                                                                  'MColor',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the value of the "transparency" attribute of a shader node.',
                                                        'inArgs': ['transp'],
                                                        'inverse': ('transparency',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'transp': ['const',
                                                                                      '&']},
                                                        'types': {'transp': 'MColor'}}],
                                   'translucenceCoeff': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nRetrieves the value of the "translucenceCoeff" attribute of a lambert shader node. This attribute represents a constant multiplier applied to the transparency attribute of the shader.',
                                                          'inArgs': [],
                                                          'inverse': ('setTranslucenceCoeff',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The value of the "translucenceCoeff" attribute of the shader node.',
                                                                         'qualifiers': [],
                                                                         'type': 'float'},
                                                          'returnType': 'float',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                   'transparency': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.',
                                                     'inArgs': [],
                                                     'inverse': ('setTransparency',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "transparency" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'MColor'},
                                                     'returnType': 'MColor',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nFunction set type. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                       'pymelEnums': {},
                       'pymelMethods': {'ambientColor': 'getAmbientColor',
                                        'color': 'getColor',
                                        'diffuseCoeff': 'getDiffuseCoeff',
                                        'glowIntensity': 'getGlowIntensity',
                                        'hideSource': 'getHideSource',
                                        'incandescence': 'getIncandescence',
                                        'refractedRayDepthLimit': 'getRefractedRayDepthLimit',
                                        'refractiveIndex': 'getRefractiveIndex',
                                        'rtRefractedColor': 'getRtRefractedColor',
                                        'translucenceCoeff': 'getTranslucenceCoeff',
                                        'transparency': 'getTransparency'}},
  'MFnLattice': {'enums': {},
                 'invertibles': [('setDivisions', 'getDivisions')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nClass name. \r\n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'create': [{'argInfo': {'parentOrOwner': {'doc': 'Parent node or data wrapper. See discussion above. ',
                                                                       'type': 'MObject'},
                                                     'xDiv': {'doc': 'Lattice divisions in x (must be at least 2). ',
                                                              'type': 'uint'},
                                                     'yDiv': {'doc': 'Lattice divisions in y (must be at least 2). ',
                                                              'type': 'uint'},
                                                     'zDiv': {'doc': 'Lattice divisions in z (must be at least 2). ',
                                                              'type': 'uint'}},
                                         'args': [('xDiv', 'uint', 'in'),
                                                  ('yDiv', 'uint', 'in'),
                                                  ('zDiv', 'uint', 'in'),
                                                  ('parentOrOwner',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nCreate a new lattice. This can be used to create either a new lattice shape in the DAG, or to place new lattice geometry into a dependency graph lattice data object. Lattice data objects can be created with  MFnLatticeData  or can be obtained from an  MDataHandle  in the compute method of a dependency node.',
                                         'inArgs': ['xDiv',
                                                    'yDiv',
                                                    'zDiv',
                                                    'parentOrOwner'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'A handle to the new lattice data, lattice node or transform node. See the discussion of the parentOrOwner parameter above for more details.',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'parentOrOwner': [],
                                                            'xDiv': ['unsigned'],
                                                            'yDiv': ['unsigned'],
                                                            'zDiv': ['unsigned']},
                                         'types': {'parentOrOwner': 'MObject',
                                                   'xDiv': 'uint',
                                                   'yDiv': 'uint',
                                                   'zDiv': 'uint'}}],
                             'getDivisions': [{'argInfo': {'s': {'doc': 'divisions in s dimension ',
                                                                 'type': 'uint'},
                                                           't': {'doc': 'divisions in t dimension ',
                                                                 'type': 'uint'},
                                                           'u': {'doc': 'divisions in u dimension',
                                                                 'type': 'uint'}},
                                               'args': [('s',
                                                         'uint',
                                                         'out'),
                                                        ('t',
                                                         'uint',
                                                         'out'),
                                                        ('u',
                                                         'uint',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the number of divisions in the lattice',
                                               'inArgs': [],
                                               'inverse': ('setDivisions',
                                                           False),
                                               'outArgs': ['s', 't', 'u'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'s': ['unsigned',
                                                                        '&'],
                                                                  't': ['unsigned',
                                                                        '&'],
                                                                  'u': ['unsigned',
                                                                        '&']},
                                               'types': {'s': 'uint',
                                                         't': 'uint',
                                                         'u': 'uint'}}],
                             'point': [{'argInfo': {'s': {'doc': 's index ',
                                                          'type': 'uint'},
                                                    't': {'doc': 't index ',
                                                          'type': 'uint'},
                                                    'u': {'doc': 'u index ',
                                                          'type': 'uint'}},
                                        'args': [('s', 'uint', 'in'),
                                                 ('t', 'uint', 'in'),
                                                 ('u', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the point in the lattice that is at the given indices',
                                        'inArgs': ['s', 't', 'u'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The point',
                                                       'qualifiers': ['&'],
                                                       'type': 'MPoint'},
                                        'returnType': 'MPoint',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           's': ['unsigned'],
                                                           't': ['unsigned'],
                                                           'u': ['unsigned']},
                                        'types': {'s': 'uint',
                                                  't': 'uint',
                                                  'u': 'uint'}}],
                             'reset': [{'argInfo': {'sSize': {'doc': 'size in s dimension ',
                                                              'type': 'double'},
                                                    'tSize': {'doc': 'size in t dimension ',
                                                              'type': 'double'},
                                                    'uSize': {'doc': 'size in u dimension',
                                                              'type': 'double'}},
                                        'args': [('sSize',
                                                  'double',
                                                  'in'),
                                                 ('tSize',
                                                  'double',
                                                  'in'),
                                                 ('uSize',
                                                  'double',
                                                  'in')],
                                        'defaults': {'sSize': 1.0,
                                                     'tSize': 1.0,
                                                     'uSize': 1.0},
                                        'deprecated': False,
                                        'doc': '\r\nReset the lattice points to a uniform parallelipiped shape with the specified dimensions: sSize x tSize x uSize',
                                        'inArgs': ['sSize',
                                                   'tSize',
                                                   'uSize'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'sSize': [],
                                                           'tSize': [],
                                                           'uSize': []},
                                        'types': {'sSize': 'double',
                                                  'tSize': 'double',
                                                  'uSize': 'double'}}],
                             'setDivisions': [{'argInfo': {'s': {'doc': 'divisions in s dimension ',
                                                                 'type': 'uint'},
                                                           't': {'doc': 'divisions in t dimension ',
                                                                 'type': 'uint'},
                                                           'u': {'doc': 'divisions in u dimension',
                                                                 'type': 'uint'}},
                                               'args': [('s',
                                                         'uint',
                                                         'in'),
                                                        ('t',
                                                         'uint',
                                                         'in'),
                                                        ('u',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the number of divisions in the lattice',
                                               'inArgs': ['s', 't', 'u'],
                                               'inverse': ('getDivisions',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'s': ['unsigned'],
                                                                  't': ['unsigned'],
                                                                  'u': ['unsigned']},
                                               'types': {'s': 'uint',
                                                         't': 'uint',
                                                         'u': 'uint'}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nFunction set type. \r\n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': ('MFn',
                                                               'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                 'pymelEnums': {}},
  'MFnLatticeData': {'enums': {},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClass name. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nThis method create a new lattice data object for use with the dependency graph. A node's lattice attribute may be set with this object using  MDataHandle .",
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A handle to the new lattice data object',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                 'lattice': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the lattice geometry so that it may be modified using the  MFnLattice  function set.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A handle to the new lattice data object',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnLatticeDeformer': {'enums': {},
                         'invertibles': [('setDivisions', 'getDivisions')],
                         'methods': {'addGeometry': [{'argInfo': {'object': {'doc': 'the geometry',
                                                                             'type': 'MObject'}},
                                                      'args': [('object',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdds a piece of geometry to the deformation.',
                                                      'inArgs': ['object'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'object': ['const',
                                                                                    '&']},
                                                      'types': {'object': 'MObject'}}],
                                     'baseLattice': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis returns the base version of the lattice that describes the region of space deformed by the lattice. The returned base lattice is a shape in the DAG and can be accessed using the  MFnDagNode  function set.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Handle for the base lattice shape',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nClass name. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'create': [{'argInfo': {'xDiv': {'doc': 'number of divisions in x (must be at least 2) ',
                                                                      'type': 'uint'},
                                                             'yDiv': {'doc': 'number of divisions in y (must be at least 2) ',
                                                                      'type': 'uint'},
                                                             'zDiv': {'doc': 'number of divisions in z (must be at least 2) ',
                                                                      'type': 'uint'}},
                                                 'args': [('xDiv',
                                                           'uint',
                                                           'in'),
                                                          ('yDiv',
                                                           'uint',
                                                           'in'),
                                                          ('zDiv',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nCreates a new lattice deformer with the given number of divisions. This function set's object is set to be the new lattice node.",
                                                 'inArgs': ['xDiv',
                                                            'yDiv',
                                                            'zDiv'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Returns a handle to the new deformer',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'xDiv': ['unsigned'],
                                                                    'yDiv': ['unsigned'],
                                                                    'zDiv': ['unsigned']},
                                                 'types': {'xDiv': 'uint',
                                                           'yDiv': 'uint',
                                                           'zDiv': 'uint'}}],
                                     'deformLattice': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis returns the deformed version of the lattice. The deformed lattice is a shape in the DAG and should be modified using the  MFnLattice  function set.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Handle for the deformed lattice shape',
                                                                       'qualifiers': [],
                                                                       'type': 'MObject'},
                                                        'returnType': 'MObject',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                     'getAffectedGeometry': [{'argInfo': {'objects': {'doc': 'storage for the returned array',
                                                                                      'type': 'MObjectArray'}},
                                                              'args': [('objects',
                                                                        'MObjectArray',
                                                                        'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nThe geometry affected by this deformer is packed into the provided list of MObjects. Each of the MObjects will be a DAG node that has geometry.',
                                                              'inArgs': [],
                                                              'outArgs': ['objects'],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'objects': ['&']},
                                                              'types': {'objects': 'MObjectArray'}}],
                                     'getDivisions': [{'argInfo': {'x': {'doc': 'a reference parameter that on return contains the number of divisions in the X direction ',
                                                                         'type': 'uint'},
                                                                   'y': {'doc': 'a reference parameter that on return contains the number of divisions in the Y direction ',
                                                                         'type': 'uint'},
                                                                   'z': {'doc': 'a reference parameter that on return contains the number of divisions in the Z direction',
                                                                         'type': 'uint'}},
                                                       'args': [('x',
                                                                 'uint',
                                                                 'out'),
                                                                ('y',
                                                                 'uint',
                                                                 'out'),
                                                                ('z',
                                                                 'uint',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nRetrieve the number of divisions in each of the X, Y, and Z directions. The number of divisions specifies the resolution of the lattice.',
                                                       'inArgs': [],
                                                       'inverse': ('setDivisions',
                                                                   False),
                                                       'outArgs': ['x',
                                                                   'y',
                                                                   'z'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'x': ['unsigned',
                                                                                '&'],
                                                                          'y': ['unsigned',
                                                                                '&'],
                                                                          'z': ['unsigned',
                                                                                '&']},
                                                       'types': {'x': 'uint',
                                                                 'y': 'uint',
                                                                 'z': 'uint'}}],
                                     'removeGeometry': [{'argInfo': {'object': {'doc': 'the geometry',
                                                                                'type': 'MObject'}},
                                                         'args': [('object',
                                                                   'MObject',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nRemoves a piece of geometry from the deformation.',
                                                         'inArgs': ['object'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'object': ['const',
                                                                                       '&']},
                                                         'types': {'object': 'MObject'}}],
                                     'resetLattice': [{'argInfo': {'centerLattice': {'doc': 'whether to center the lattice',
                                                                                     'type': 'bool'}},
                                                       'args': [('centerLattice',
                                                                 'bool',
                                                                 'in')],
                                                       'defaults': {'centerLattice': False},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method resets the deformed lattice to match the base lattice.',
                                                       'inArgs': ['centerLattice'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'centerLattice': []},
                                                       'types': {'centerLattice': 'bool'}}],
                                     'setDivisions': [{'argInfo': {'x': {'doc': 'number of divisions in the X direction ',
                                                                         'type': 'uint'},
                                                                   'y': {'doc': 'number of divisions in the Y direction ',
                                                                         'type': 'uint'},
                                                                   'z': {'doc': 'number of divisions in the Z direction',
                                                                         'type': 'uint'}},
                                                       'args': [('x',
                                                                 'uint',
                                                                 'in'),
                                                                ('y',
                                                                 'uint',
                                                                 'in'),
                                                                ('z',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet the number of divisions in each of the X, Y, and Z directions. The number of divisions specifies the resolution of the lattice.',
                                                       'inArgs': ['x',
                                                                  'y',
                                                                  'z'],
                                                       'inverse': ('getDivisions',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'x': ['unsigned'],
                                                                          'y': ['unsigned'],
                                                                          'z': ['unsigned']},
                                                       'types': {'x': 'uint',
                                                                 'y': 'uint',
                                                                 'z': 'uint'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFunction set type. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnLayeredShader': {'enums': {},
                       'invertibles': [('setGlowColor', 'glowColor'),
                                       ('setHardwareShader',
                                        'hardwareShader'),
                                       ('setTransparency', 'transparency'),
                                       ('setCompositingFlag',
                                        'compositingFlag'),
                                       ('setHardwareColor',
                                        'hardwareColor'),
                                       ('setColor', 'color')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nClass name. \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'color': [{'argInfo': {'lIndex': {'doc': "Index of the shader's entry in the inputs attribute array element. ",
                                                                     'type': 'uint'}},
                                              'args': [('lIndex',
                                                        'uint',
                                                        'in')],
                                              'defaults': {'lIndex': 0},
                                              'deprecated': False,
                                              'doc': '\nRetrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.',
                                              'inArgs': ['lIndex'],
                                              'inverse': ('setColor',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the "color" attribute of the shader node.',
                                                             'qualifiers': [],
                                                             'type': 'MColor'},
                                              'returnType': 'MColor',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'lIndex': ['unsigned']},
                                              'types': {'lIndex': 'uint'}}],
                                   'compositingFlag': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieves the value of the "compositingFlag" attribute of a shader node.',
                                                        'inArgs': [],
                                                        'inverse': ('setCompositingFlag',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "compositingFlag" attribute of the shader node.',
                                                                       'qualifiers': [],
                                                                       'type': 'short'},
                                                        'returnType': 'short',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                   'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not the new node will be connected to the shader classification node. ',
                                                                         'type': 'bool'}},
                                               'args': [('UIvisible',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'UIvisible': True},
                                               'deprecated': False,
                                               'doc': '\nCreates a new layered shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.',
                                               'inArgs': ['UIvisible'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'UIvisible': []},
                                               'types': {'UIvisible': 'bool'}}],
                                   'glowColor': [{'argInfo': {'lIndex': {'doc': "Index of the shader's entry in the inputs attribute array element. ",
                                                                         'type': 'uint'}},
                                                  'args': [('lIndex',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {'lIndex': 0},
                                                  'deprecated': False,
                                                  'doc': '\nRetrieves the value of the "glowColor" attribute of a shader node. This attribute represents the ambient color of the shader.',
                                                  'inArgs': ['lIndex'],
                                                  'inverse': ('setGlowColor',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the "glowColor" attribute of the shader node.',
                                                                 'qualifiers': [],
                                                                 'type': 'MColor'},
                                                  'returnType': 'MColor',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'lIndex': ['unsigned']},
                                                  'types': {'lIndex': 'uint'}}],
                                   'hardwareColor': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nRetrieves the value of the "hardwareColor" attribute of a shader node. This attribute represents the color of the material that appears in shaded mode.',
                                                      'inArgs': [],
                                                      'inverse': ('setHardwareColor',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The value of the "hardwareColor" attribute of the shader node.',
                                                                     'qualifiers': [],
                                                                     'type': 'MColor'},
                                                      'returnType': 'MColor',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'hardwareShader': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nRetrieves the value of the "hardwareShader" attribute of a layered shader node.',
                                                       'inArgs': [],
                                                       'inverse': ('setHardwareShader',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The value of the "hardwareShader" attribute of the shader node.',
                                                                      'qualifiers': [],
                                                                      'type': 'MColor'},
                                                       'returnType': 'MColor',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                   'setColor': [{'argInfo': {'col': {'doc': 'Color. ',
                                                                     'type': 'MColor'},
                                                             'lIndex': {'doc': "Index of the shader's entry in the inputs attribute array element.",
                                                                        'type': 'uint'}},
                                                 'args': [('col',
                                                           'MColor',
                                                           'in'),
                                                          ('lIndex',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {'lIndex': 0},
                                                 'deprecated': False,
                                                 'doc': '\nSets the value of the "color" attribute of a shader node.',
                                                 'inArgs': ['col',
                                                            'lIndex'],
                                                 'inverse': ('color',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'col': ['const',
                                                                            '&'],
                                                                    'lIndex': ['unsigned']},
                                                 'types': {'col': 'MColor',
                                                           'lIndex': 'uint'}}],
                                   'setCompositingFlag': [{'argInfo': {'cflag': {'doc': 'value to which the attribute will be set.',
                                                                                 'type': 'short'}},
                                                           'args': [('cflag',
                                                                     'short',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the value of the "compositingFlag" attribute of a shader node.',
                                                           'inArgs': ['cflag'],
                                                           'inverse': ('compositingFlag',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'cflag': ['const',
                                                                                        '&']},
                                                           'types': {'cflag': 'short'}}],
                                   'setGlowColor': [{'argInfo': {'glow_color': {'doc': 'Color to which the attribute will be set. ',
                                                                                'type': 'MColor'},
                                                                 'lIndex': {'doc': "Index of the shader's entry in the inputs attribute array element.",
                                                                            'type': 'uint'}},
                                                     'args': [('glow_color',
                                                               'MColor',
                                                               'in'),
                                                              ('lIndex',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {'lIndex': 0},
                                                     'deprecated': False,
                                                     'doc': '\nSets the value of the "glowColor" attribute of a shader node.',
                                                     'inArgs': ['glow_color',
                                                                'lIndex'],
                                                     'inverse': ('glowColor',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'glow_color': ['const',
                                                                                       '&'],
                                                                        'lIndex': ['unsigned']},
                                                     'types': {'glow_color': 'MColor',
                                                               'lIndex': 'uint'}}],
                                   'setHardwareColor': [{'argInfo': {'hardware_color': {'doc': 'value to which the attribute will be set.',
                                                                                        'type': 'MColor'}},
                                                         'args': [('hardware_color',
                                                                   'MColor',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the value of the "hardwareColor" attribute of a shader node.',
                                                         'inArgs': ['hardware_color'],
                                                         'inverse': ('hardwareColor',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'hardware_color': ['const',
                                                                                               '&']},
                                                         'types': {'hardware_color': 'MColor'}}],
                                   'setHardwareShader': [{'argInfo': {'hardware_shader': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'MColor'}},
                                                          'args': [('hardware_shader',
                                                                    'MColor',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the value of the "hardwareShader" attribute of a shader node.',
                                                          'inArgs': ['hardware_shader'],
                                                          'inverse': ('hardwareShader',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'hardware_shader': ['const',
                                                                                                 '&']},
                                                          'types': {'hardware_shader': 'MColor'}}],
                                   'setTransparency': [{'argInfo': {'lIndex': {'doc': "Index of the shader's entry in the inputs attribute array element.",
                                                                               'type': 'uint'},
                                                                    'transp': {'doc': 'Value to which the attribute will be set. ',
                                                                               'type': 'MColor'}},
                                                        'args': [('transp',
                                                                  'MColor',
                                                                  'in'),
                                                                 ('lIndex',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {'lIndex': 0},
                                                        'deprecated': False,
                                                        'doc': '\nSets the value of the "transparency" attribute of a shader node.',
                                                        'inArgs': ['transp',
                                                                   'lIndex'],
                                                        'inverse': ('transparency',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'lIndex': ['unsigned'],
                                                                           'transp': ['const',
                                                                                      '&']},
                                                        'types': {'lIndex': 'uint',
                                                                  'transp': 'MColor'}}],
                                   'transparency': [{'argInfo': {'lIndex': {'doc': "Index of the shader's entry in the inputs attribute array element. ",
                                                                            'type': 'uint'}},
                                                     'args': [('lIndex',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {'lIndex': 0},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.',
                                                     'inArgs': ['lIndex'],
                                                     'inverse': ('setTransparency',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "transparency" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'MColor'},
                                                     'returnType': 'MColor',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'lIndex': ['unsigned']},
                                                     'types': {'lIndex': 'uint'}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nFunction set type. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                       'pymelEnums': {},
                       'pymelMethods': {'color': 'getColor',
                                        'compositingFlag': 'getCompositingFlag',
                                        'glowColor': 'getGlowColor',
                                        'hardwareColor': 'getHardwareColor',
                                        'hardwareShader': 'getHardwareShader',
                                        'transparency': 'getTransparency'}},
  'MFnLight': {'enums': {},
               'invertibles': [('setUseRayTraceShadows',
                                'useRayTraceShadows'),
                               ('setOpticalFXvisibility',
                                'opticalFXvisibility'),
                               ('setCenterOfIllumination',
                                'centerOfIllumination'),
                               ('setNumShadowSamples', 'numShadowSamples'),
                               ('setShadowColor', 'shadowColor'),
                               ('setColor', 'color'),
                               ('setIntensity', 'intensity'),
                               ('setRayDepthLimit', 'rayDepthLimit')],
               'methods': {'centerOfIllumination': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nRetrieves the value of the "centerOfIllumination" attribute of a light node. This attribute represents the distance to the center of illumination of the light.',
                                                     'inArgs': [],
                                                     'inverse': ('setCenterOfIllumination',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "centerOfIllumination" attribute of the light node.',
                                                                    'qualifiers': [],
                                                                    'type': 'double',
                                                                    'unitType': u'linear'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                           'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nClass name. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'color': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nRetrieves the value of the "color" attribute of a light node. This attribute represents the color of the light emitted by the light node.',
                                      'inArgs': [],
                                      'inverse': ('setColor', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The value of the "color" attribute of the light node.',
                                                     'qualifiers': [],
                                                     'type': 'MColor'},
                                      'returnType': 'MColor',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                           'intensity': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nRetrieves the value of the "intensity" attribute of a light node. This attribute represents a uniform scaling factor applied to the light color.',
                                          'inArgs': [],
                                          'inverse': ('setIntensity',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The value of the "intensity" attribute of the light node.',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                           'lightAmbient': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nRetrieves the value of the "lightAmbient" attribute of a light node. This attribute indicates if the light has an ambient component.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The value of the "lightAmbient" attribute of the light node.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                           'lightDiffuse': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nRetrieves the value of the "lightDiffuse" attribute of a light node. This attribute indicates if the light has a diffuse component.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The value of the "lightDiffuse" attribute of the light node.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                           'lightDirection': [{'argInfo': {'instance': {'doc': 'The instance of the light for which to return the direction. ',
                                                                        'type': 'int'},
                                                           'space': {'doc': 'The coordinate space for which the direction vector is returned. If MSpace::kWorld is passed in the vector will be in the lights world space. If any other MSpace::Space value in pass in the vector will be returned in object (or local) space. ',
                                                                     'type': ('MSpace',
                                                                              'Space')}},
                                               'args': [('instance',
                                                         'int',
                                                         'in'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kWorld')},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the direction in which the light is pointing. This is only valid for lights which are associated with a direction, such as area, directional or spot lights. The vector returned is not normalized.',
                                               'inArgs': ['instance',
                                                          'space'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A vector containing the direction of the light is the specified coordinate system.',
                                                              'qualifiers': [],
                                                              'type': 'MFloatVector'},
                                               'returnType': 'MFloatVector',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'instance': [],
                                                                  'space': []},
                                               'types': {'instance': 'int',
                                                         'space': ('MSpace',
                                                                   'Space')}},
                                              {'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRetrieves the value of the "lightDirection" attribute of a light node. This attribute represents the direction from the light to the point being shading.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the "lightDirection" attribute of the light node.',
                                                              'qualifiers': [],
                                                              'type': 'MFloatVector'},
                                               'returnType': 'MFloatVector',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                           'lightIntensity': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRetrieves the value of the "lightIntensity" attribute of a light node. This attribute represents the intensity of the light specified as a color.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the "lightIntensity" attribute of the light node.',
                                                              'qualifiers': [],
                                                              'type': 'MColor'},
                                               'returnType': 'MColor',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                           'lightSpecular': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRetrieves the value of the "lightSpecular" attribute of a light node. This attribute indicates if the light has a specular component.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the "lightSpecular" attribute of the light node.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                           'numShadowSamples': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nRetrieves the value of the "numShadowSamples" attribute of a light node. This attribute represents the number of shadow samples per point used in occulusion testing.',
                                                 'inArgs': [],
                                                 'inverse': ('setNumShadowSamples',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The value of the "numShadowSamples" attribute of the light node.',
                                                                'qualifiers': [],
                                                                'type': 'short'},
                                                 'returnType': 'short',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                           'opticalFXvisibility': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRetrieves the value of the "opticalFXvisibility" attribute of a light node. This attribute represents an occlusion scaling factor for light glow effects on this light.',
                                                    'inArgs': [],
                                                    'inverse': ('setOpticalFXvisibility',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the "opticalFXvisibility" attribute of the light node.',
                                                                   'qualifiers': [],
                                                                   'type': 'MColor'},
                                                    'returnType': 'MColor',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                           'rayDepthLimit': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRetrieves the value of the "rayDepthLimit" attribute of a light node. This attribute determines a cutoff point for shadow calculations related to the light. Rays whose depth is higher than the value of this attribute will not trigger a shadow calculation for the light.',
                                              'inArgs': [],
                                              'inverse': ('setRayDepthLimit',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the "rayDepthLimit" attribute of the light node.',
                                                             'qualifiers': [],
                                                             'type': 'short'},
                                              'returnType': 'short',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                           'setCenterOfIllumination': [{'argInfo': {'dist': {'doc': 'value to which the attribute will be set.',
                                                                             'type': 'double',
                                                                             'unitType': u'linear'}},
                                                        'args': [('dist',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the value of the "centerOfIllumination" attribute of a light node.',
                                                        'inArgs': ['dist'],
                                                        'inverse': ('centerOfIllumination',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'dist': ['const',
                                                                                    '&']},
                                                        'types': {'dist': 'double'}}],
                           'setColor': [{'argInfo': {'col': {'doc': 'value to which the attribute will be set.',
                                                             'type': 'MColor'}},
                                         'args': [('col',
                                                   'MColor',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSets the value of the "color" attribute of a light node.',
                                         'inArgs': ['col'],
                                         'inverse': ('color', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'col': ['const',
                                                                    '&']},
                                         'types': {'col': 'MColor'}}],
                           'setIntensity': [{'argInfo': {'intens': {'doc': 'value to which the attribute will be set.',
                                                                    'type': 'float'}},
                                             'args': [('intens',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the value of the "intensity" attribute of a light node.',
                                             'inArgs': ['intens'],
                                             'inverse': ('intensity',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'intens': ['const',
                                                                           '&']},
                                             'types': {'intens': 'float'}}],
                           'setNumShadowSamples': [{'argInfo': {'num_shadow_samples': {'doc': 'value to which the attribute will be set.',
                                                                                       'type': 'short'}},
                                                    'args': [('num_shadow_samples',
                                                              'short',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the value of the "numShadowSamples" attribute of a light node.',
                                                    'inArgs': ['num_shadow_samples'],
                                                    'inverse': ('numShadowSamples',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'num_shadow_samples': ['const',
                                                                                              '&']},
                                                    'types': {'num_shadow_samples': 'short'}}],
                           'setOpticalFXvisibility': [{'argInfo': {'visibility': {'doc': 'value to which the attribute will be set.',
                                                                                  'type': 'MColor'}},
                                                       'args': [('visibility',
                                                                 'MColor',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the value of the "opticalFXvisibility" attribute of a light node.',
                                                       'inArgs': ['visibility'],
                                                       'inverse': ('opticalFXvisibility',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'visibility': ['const',
                                                                                         '&']},
                                                       'types': {'visibility': 'MColor'}}],
                           'setRayDepthLimit': [{'argInfo': {'ray_depth_limit': {'doc': 'value to which the attribute will be set.',
                                                                                 'type': 'short'}},
                                                 'args': [('ray_depth_limit',
                                                           'short',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the value of the "rayDepthLimit" attribute of a light node.',
                                                 'inArgs': ['ray_depth_limit'],
                                                 'inverse': ('rayDepthLimit',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'ray_depth_limit': ['const',
                                                                                        '&']},
                                                 'types': {'ray_depth_limit': 'short'}}],
                           'setShadowColor': [{'argInfo': {'shadow_color': {'doc': 'value to which the attribute will be set.',
                                                                            'type': 'MColor'}},
                                               'args': [('shadow_color',
                                                         'MColor',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets the value of the "shadowColor" attribute of a light node.',
                                               'inArgs': ['shadow_color'],
                                               'inverse': ('shadowColor',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'shadow_color': ['const',
                                                                                   '&']},
                                               'types': {'shadow_color': 'MColor'}}],
                           'setUseRayTraceShadows': [{'argInfo': {'useRayTraceShadows': {'doc': 'value to which the attribute will be set.',
                                                                                         'type': 'bool'}},
                                                      'args': [('useRayTraceShadows',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the value of the "useRayTraceShadows" attribute of a light node.',
                                                      'inArgs': ['useRayTraceShadows'],
                                                      'inverse': ('useRayTraceShadows',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'useRayTraceShadows': ['const',
                                                                                                '&']},
                                                      'types': {'useRayTraceShadows': 'bool'}}],
                           'shadowColor': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nRetrieves the value of the "shadowColor" attribute of a light node. This attribute represents the color of the shadows cast by the light.',
                                            'inArgs': [],
                                            'inverse': ('setShadowColor',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The value of the "shadowColor" attribute of the light node.',
                                                           'qualifiers': [],
                                                           'type': 'MColor'},
                                            'returnType': 'MColor',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                           'type': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nFunction set type. \r\n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': ('MFn',
                                                             'Type')},
                                     'returnType': ('MFn', 'Type'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                           'useRayTraceShadows': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the value of the "useRayTraceShadows" attribute of a light node. This attribute determines whether or not the light should raytrace it\'s shadows.',
                                                   'inArgs': [],
                                                   'inverse': ('setUseRayTraceShadows',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The value of the "useRayTraceShadows" attribute of the light node.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}]},
               'pymelEnums': {},
               'pymelMethods': {'centerOfIllumination': 'getCenterOfIllumination',
                                'color': 'getColor',
                                'intensity': 'getIntensity',
                                'numShadowSamples': 'getNumShadowSamples',
                                'opticalFXvisibility': 'getOpticalFXvisibility',
                                'rayDepthLimit': 'getRayDepthLimit',
                                'shadowColor': 'getShadowColor',
                                'useRayTraceShadows': 'getUseRayTraceShadows'}},
  'MFnLightDataAttribute': {'enums': {},
                            'invertibles': [('setDefault', 'getDefault')],
                            'methods': {'child': [{'argInfo': {'index': {'doc': 'Specifies which child is desired:  0 = direction  1 = intensity  2 = ambient flag  3 = diffuse flag  4 = specular flag  5 = shadow fraction flag  6 = pre shadow intensity flag  7 = blind data flag  ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGets a pointer to one of the child attributes.',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'A pointer to the desired child attribute',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                                        'className': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nClass name. \r\n',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'char'},
                                                       'returnType': 'char',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        'create': [{'argInfo': {'ambient': {'doc': 'The Boolean child attribute that specifies whether or not the light contributes to the ambient component of the shading model ',
                                                                            'type': 'MObject'},
                                                                'blindData': {'doc': "Attribute to hold the light's blind data. ",
                                                                              'type': 'MObject'},
                                                                'briefName': {'doc': 'The brief name of the attribute ',
                                                                              'type': 'MString'},
                                                                'diffuse': {'doc': 'The Boolean child attribute that specifies whether or not the light contributes to the diffuse component of the shading model ',
                                                                            'type': 'MObject'},
                                                                'direction': {'doc': 'The 3Float child attribute that will represent the light direction ',
                                                                              'type': 'MObject'},
                                                                'fullName': {'doc': 'The full name of the attribute ',
                                                                             'type': 'MString'},
                                                                'intensity': {'doc': 'The 3Float child attibute that will represent the light intensity ',
                                                                              'type': 'MObject'},
                                                                'preShadowIntensity': {'doc': 'The float attribute that will represetnt the light intensity without shadow consideration ',
                                                                                       'type': 'MObject'},
                                                                'shadowFraction': {'doc': 'The float attribute that will represent the percentage of the light that is in shadow with respect to the intersection point. 0 means the light is total visible to the intersection point and 1 means the light is total invisible to the intersection point. ',
                                                                                   'type': 'MObject'},
                                                                'specular': {'doc': 'The Boolean child attribute that specifies whether or not the light contributes to the specular component of the shading model ',
                                                                             'type': 'MObject'}},
                                                    'args': [('fullName',
                                                              'MString',
                                                              'in'),
                                                             ('briefName',
                                                              'MString',
                                                              'in'),
                                                             ('direction',
                                                              'MObject',
                                                              'in'),
                                                             ('intensity',
                                                              'MObject',
                                                              'in'),
                                                             ('ambient',
                                                              'MObject',
                                                              'in'),
                                                             ('diffuse',
                                                              'MObject',
                                                              'in'),
                                                             ('specular',
                                                              'MObject',
                                                              'in'),
                                                             ('shadowFraction',
                                                              'MObject',
                                                              'in'),
                                                             ('preShadowIntensity',
                                                              'MObject',
                                                              'in'),
                                                             ('blindData',
                                                              'MObject',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nCreates a LightData attribute object.',
                                                    'inArgs': ['fullName',
                                                               'briefName',
                                                               'direction',
                                                               'intensity',
                                                               'ambient',
                                                               'diffuse',
                                                               'specular',
                                                               'shadowFraction',
                                                               'preShadowIntensity',
                                                               'blindData'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The newly created LightData attribute object.',
                                                                   'qualifiers': [],
                                                                   'type': 'MObject'},
                                                    'returnType': 'MObject',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'ambient': ['const',
                                                                                   '&'],
                                                                       'blindData': ['const',
                                                                                     '&'],
                                                                       'briefName': ['const',
                                                                                     '&'],
                                                                       'diffuse': ['const',
                                                                                   '&'],
                                                                       'direction': ['const',
                                                                                     '&'],
                                                                       'fullName': ['const',
                                                                                    '&'],
                                                                       'intensity': ['const',
                                                                                     '&'],
                                                                       'preShadowIntensity': ['const',
                                                                                              '&'],
                                                                       'shadowFraction': ['const',
                                                                                          '&'],
                                                                       'specular': ['const',
                                                                                    '&']},
                                                    'types': {'ambient': 'MObject',
                                                              'blindData': 'MObject',
                                                              'briefName': 'MString',
                                                              'diffuse': 'MObject',
                                                              'direction': 'MObject',
                                                              'fullName': 'MString',
                                                              'intensity': 'MObject',
                                                              'preShadowIntensity': 'MObject',
                                                              'shadowFraction': 'MObject',
                                                              'specular': 'MObject'}}],
                                        'getDefault': [{'argInfo': {'defAmbient': {'doc': 'returns the default ambient flag ',
                                                                                   'type': 'bool'},
                                                                    'defBlindData': {'doc': 'returns the default blind data',
                                                                                     'type': 'void'},
                                                                    'defDiffuse': {'doc': 'returns the default diffuse flag ',
                                                                                   'type': 'bool'},
                                                                    'defDirectionX': {'doc': 'returns the default x component of light direction ',
                                                                                      'type': 'float'},
                                                                    'defDirectionY': {'doc': 'returns the default y component of light direction ',
                                                                                      'type': 'float'},
                                                                    'defDirectionZ': {'doc': 'returns the default z component of light direction ',
                                                                                      'type': 'float'},
                                                                    'defIntensityB': {'doc': 'returns the default blue component of light intensity ',
                                                                                      'type': 'float'},
                                                                    'defIntensityG': {'doc': 'returns the default green component of light intensity ',
                                                                                      'type': 'float'},
                                                                    'defIntensityR': {'doc': 'returns the default red component of light intensity ',
                                                                                      'type': 'float'},
                                                                    'defPreShadowIntensity': {'doc': 'returns the default pre shadow intensity flag ',
                                                                                              'type': 'float'},
                                                                    'defShadowFraction': {'doc': 'returns the default shadow fraction flag ',
                                                                                          'type': 'float'},
                                                                    'defSpecular': {'doc': 'returns the default specular flag ',
                                                                                    'type': 'bool'}},
                                                        'args': [('defDirectionX',
                                                                  'float',
                                                                  'out'),
                                                                 ('defDirectionY',
                                                                  'float',
                                                                  'out'),
                                                                 ('defDirectionZ',
                                                                  'float',
                                                                  'out'),
                                                                 ('defIntensityR',
                                                                  'float',
                                                                  'out'),
                                                                 ('defIntensityG',
                                                                  'float',
                                                                  'out'),
                                                                 ('defIntensityB',
                                                                  'float',
                                                                  'out'),
                                                                 ('defAmbient',
                                                                  'bool',
                                                                  'out'),
                                                                 ('defDiffuse',
                                                                  'bool',
                                                                  'out'),
                                                                 ('defSpecular',
                                                                  'bool',
                                                                  'out'),
                                                                 ('defShadowFraction',
                                                                  'float',
                                                                  'out'),
                                                                 ('defPreShadowIntensity',
                                                                  'float',
                                                                  'out'),
                                                                 ('defBlindData',
                                                                  'void',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGets the default value for the attribute.',
                                                        'inArgs': [],
                                                        'inverse': ('setDefault',
                                                                    False),
                                                        'outArgs': ['defDirectionX',
                                                                    'defDirectionY',
                                                                    'defDirectionZ',
                                                                    'defIntensityR',
                                                                    'defIntensityG',
                                                                    'defIntensityB',
                                                                    'defAmbient',
                                                                    'defDiffuse',
                                                                    'defSpecular',
                                                                    'defShadowFraction',
                                                                    'defPreShadowIntensity',
                                                                    'defBlindData'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'defAmbient': ['&'],
                                                                           'defBlindData': ['*&'],
                                                                           'defDiffuse': ['&'],
                                                                           'defDirectionX': ['&'],
                                                                           'defDirectionY': ['&'],
                                                                           'defDirectionZ': ['&'],
                                                                           'defIntensityB': ['&'],
                                                                           'defIntensityG': ['&'],
                                                                           'defIntensityR': ['&'],
                                                                           'defPreShadowIntensity': ['&'],
                                                                           'defShadowFraction': ['&'],
                                                                           'defSpecular': ['&']},
                                                        'types': {'defAmbient': 'bool',
                                                                  'defBlindData': 'void',
                                                                  'defDiffuse': 'bool',
                                                                  'defDirectionX': 'float',
                                                                  'defDirectionY': 'float',
                                                                  'defDirectionZ': 'float',
                                                                  'defIntensityB': 'float',
                                                                  'defIntensityG': 'float',
                                                                  'defIntensityR': 'float',
                                                                  'defPreShadowIntensity': 'float',
                                                                  'defShadowFraction': 'float',
                                                                  'defSpecular': 'bool'}}],
                                        'setDefault': [{'argInfo': {'defAmbient': {'doc': 'Default ambient flag ',
                                                                                   'type': 'bool'},
                                                                    'defBlindData': {'doc': 'Default blind data',
                                                                                     'type': 'void'},
                                                                    'defDiffuse': {'doc': 'Default diffuse flag ',
                                                                                   'type': 'bool'},
                                                                    'defDirectionX': {'doc': 'Default x component of light direction ',
                                                                                      'type': 'float'},
                                                                    'defDirectionY': {'doc': 'Default y component of light direction ',
                                                                                      'type': 'float'},
                                                                    'defDirectionZ': {'doc': 'Default z component of light direction ',
                                                                                      'type': 'float'},
                                                                    'defIntensityB': {'doc': 'Default blue component of light intensity ',
                                                                                      'type': 'float'},
                                                                    'defIntensityG': {'doc': 'Default green component of light intensity ',
                                                                                      'type': 'float'},
                                                                    'defIntensityR': {'doc': 'Default red component of light intensity ',
                                                                                      'type': 'float'},
                                                                    'defPreShadowIntensity': {'doc': 'Default pre shadow intensity flag ',
                                                                                              'type': 'float'},
                                                                    'defShadowFraction': {'doc': 'Default shadow fraction flag ',
                                                                                          'type': 'float'},
                                                                    'defSpecular': {'doc': 'Default specular flag ',
                                                                                    'type': 'bool'}},
                                                        'args': [('defDirectionX',
                                                                  'float',
                                                                  'in'),
                                                                 ('defDirectionY',
                                                                  'float',
                                                                  'in'),
                                                                 ('defDirectionZ',
                                                                  'float',
                                                                  'in'),
                                                                 ('defIntensityR',
                                                                  'float',
                                                                  'in'),
                                                                 ('defIntensityG',
                                                                  'float',
                                                                  'in'),
                                                                 ('defIntensityB',
                                                                  'float',
                                                                  'in'),
                                                                 ('defAmbient',
                                                                  'bool',
                                                                  'in'),
                                                                 ('defDiffuse',
                                                                  'bool',
                                                                  'in'),
                                                                 ('defSpecular',
                                                                  'bool',
                                                                  'in'),
                                                                 ('defShadowFraction',
                                                                  'float',
                                                                  'in'),
                                                                 ('defPreShadowIntensity',
                                                                  'float',
                                                                  'in'),
                                                                 ('defBlindData',
                                                                  'void',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the default value for the attribute.',
                                                        'inArgs': ['defDirectionX',
                                                                   'defDirectionY',
                                                                   'defDirectionZ',
                                                                   'defIntensityR',
                                                                   'defIntensityG',
                                                                   'defIntensityB',
                                                                   'defAmbient',
                                                                   'defDiffuse',
                                                                   'defSpecular',
                                                                   'defShadowFraction',
                                                                   'defPreShadowIntensity',
                                                                   'defBlindData'],
                                                        'inverse': ('getDefault',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'defAmbient': [],
                                                                           'defBlindData': ['*'],
                                                                           'defDiffuse': [],
                                                                           'defDirectionX': [],
                                                                           'defDirectionY': [],
                                                                           'defDirectionZ': [],
                                                                           'defIntensityB': [],
                                                                           'defIntensityG': [],
                                                                           'defIntensityR': [],
                                                                           'defPreShadowIntensity': [],
                                                                           'defShadowFraction': [],
                                                                           'defSpecular': []},
                                                        'types': {'defAmbient': 'bool',
                                                                  'defBlindData': 'void',
                                                                  'defDiffuse': 'bool',
                                                                  'defDirectionX': 'float',
                                                                  'defDirectionY': 'float',
                                                                  'defDirectionZ': 'float',
                                                                  'defIntensityB': 'float',
                                                                  'defIntensityG': 'float',
                                                                  'defIntensityR': 'float',
                                                                  'defPreShadowIntensity': 'float',
                                                                  'defShadowFraction': 'float',
                                                                  'defSpecular': 'bool'}}],
                                        'type': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nFunction set type. \r\n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': ('MFn',
                                                                          'Type')},
                                                  'returnType': ('MFn',
                                                                 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                            'pymelEnums': {}},
  'MFnManip3D': {'enums': {},
                 'invertibles': [('setManipScale', 'manipScale'),
                                 ('setGlobalSize', 'globalSize'),
                                 ('setLineSize', 'lineSize'),
                                 ('setHandleSize', 'handleSize'),
                                 ('setDrawPlaneHandles',
                                  'drawPlaneHandles'),
                                 ('setVisible', 'isVisible')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nClass name. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'deleteManipulator': [{'argInfo': {'manip': {'doc': 'the manipulator to be deleted',
                                                                          'type': 'MObject'}},
                                                    'args': [('manip',
                                                              'MObject',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nDelete a manipulator. This method should be used to delete manipulators that have been created using base manipulator  create()  methods.',
                                                    'inArgs': ['manip'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'manip': ['&']},
                                                    'types': {'manip': 'MObject'}}],
                             'drawPlaneHandles': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nThis method returns the global option that says if the planar manipulator handles should be drawn or not.',
                                                   'inArgs': [],
                                                   'inverse': ('setDrawPlaneHandles',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                             'globalSize': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the global manipulator size.',
                                             'inArgs': [],
                                             'inverse': ('setGlobalSize',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                             'handleSize': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the manipulator handle size.',
                                             'inArgs': [],
                                             'inverse': ('setHandleSize',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                             'isOptimizePlaybackOn': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns whether or not optimize playback is on',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': ' true optimize playback is on  false optimize playback is off  ',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                             'isVisible': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns whether or not the manipulator is visible.',
                                            'inArgs': [],
                                            'inverse': ('setVisible',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true the manipulator is visible  false the manipulator is not visible  ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                             'lineSize': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the manipulator line size.',
                                           'inArgs': [],
                                           'inverse': ('setLineSize',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                             'manipScale': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the manipulator scale.',
                                             'inArgs': [],
                                             'inverse': ('setManipScale',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The manipulator scale',
                                                            'qualifiers': [],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                             'rotateXYZValue': [{'argInfo': {'valIndex': {'doc': 'rotation index of the manipulator ',
                                                                          'type': 'uint'}},
                                                 'args': [('valIndex',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nGets the rotation for the active manipulator.',
                                                 'inArgs': ['valIndex'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Rotate value of the active manip',
                                                                'qualifiers': [],
                                                                'type': 'MEulerRotation'},
                                                 'returnType': 'MEulerRotation',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'valIndex': ['const',
                                                                                 'unsigned']},
                                                 'types': {'valIndex': 'uint'}}],
                             'setDrawPlaneHandles': [{'argInfo': {'drawPlaneHandles': {'doc': 'if the planar handles should be drawn or not. ',
                                                                                       'type': 'bool'}},
                                                      'args': [('drawPlaneHandles',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets the global option to display planar handles or not on supported manipulators.',
                                                      'inArgs': ['drawPlaneHandles'],
                                                      'inverse': ('drawPlaneHandles',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'drawPlaneHandles': []},
                                                      'types': {'drawPlaneHandles': 'bool'}}],
                             'setGlobalSize': [{'argInfo': {'size': {'doc': 'the global manipulator size ',
                                                                     'type': 'float'}},
                                                'args': [('size',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSets the global manipulator size.',
                                                'inArgs': ['size'],
                                                'inverse': ('globalSize',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'size': []},
                                                'types': {'size': 'float'}}],
                             'setHandleSize': [{'argInfo': {'size': {'doc': 'the manipulator handle size ',
                                                                     'type': 'float'}},
                                                'args': [('size',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSets the manipulator handle size.',
                                                'inArgs': ['size'],
                                                'inverse': ('handleSize',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'size': []},
                                                'types': {'size': 'float'}}],
                             'setLineSize': [{'argInfo': {'size': {'doc': 'the manipulator line size ',
                                                                   'type': 'float'}},
                                              'args': [('size',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSets the manipulator line size.',
                                              'inArgs': ['size'],
                                              'inverse': ('lineSize',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'size': []},
                                              'types': {'size': 'float'}}],
                             'setManipScale': [{'argInfo': {'size': {'doc': 'the manipulator scale',
                                                                     'type': 'float'}},
                                                'args': [('size',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSets the manipulator scale.',
                                                'inArgs': ['size'],
                                                'inverse': ('manipScale',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'size': []},
                                                'types': {'size': 'float'}}],
                             'setOptimizePlayback': [{'argInfo': {'optimizePlayback': {'doc': 'whether or not to optimize the playback',
                                                                                       'type': 'bool'}},
                                                      'args': [('optimizePlayback',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets whether or not to optimize the playback',
                                                      'inArgs': ['optimizePlayback'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'optimizePlayback': []},
                                                      'types': {'optimizePlayback': 'bool'}}],
                             'setVisible': [{'argInfo': {'isVisible': {'doc': 'whether or not the manipulator is visible',
                                                                       'type': 'bool'}},
                                             'args': [('isVisible',
                                                       'bool',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSets whether or not the manipulator is visible.',
                                             'inArgs': [],
                                             'inverse': ('isVisible',
                                                         True),
                                             'outArgs': ['isVisible'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'isVisible': []},
                                             'types': {'isVisible': 'bool'}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nFunction set type. \n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': ('MFn',
                                                               'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'drawPlaneHandles': 'getDrawPlaneHandles',
                                  'globalSize': 'getGlobalSize',
                                  'handleSize': 'getHandleSize',
                                  'lineSize': 'getLineSize',
                                  'manipScale': 'getManipScale'}},
  'MFnMatrixArrayData': {'enums': {},
                         'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the MMatrix to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nNO SCRIPT SUPPORT. \n',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated MMatrix ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MMatrix'},
                                                      'returnType': 'MMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}},
                                                     {'argInfo': {'index': {'doc': 'the index of the MMatrix to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nNO SCRIPT SUPPORT. \n',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated MMatrix ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MMatrix'},
                                                      'returnType': 'MMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                                     'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nGet an  MMatrixArray  containing the matrices stored in this instance. The  MMatrixArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A copy of the MMatrixArray held in this instance ',
                                                               'qualifiers': [],
                                                               'type': 'MMatrixArray'},
                                                'returnType': 'MMatrixArray',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nClass name. \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MMatrixArray to populate',
                                                                      'type': 'MMatrixArray'}},
                                                 'args': [('dest',
                                                           'MMatrixArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nCopy all the matrices in the instance into the given  MMatrixArray . No checking is done by this class on sizes, so it is up to the user to ensure that the given  MMatrixArray  is large enough to hold the number of MPoints in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': ['dest'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'dest': ['&']},
                                                 'types': {'dest': 'MMatrixArray'}}],
                                     'create': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nCreate a new  MObject , attach it to this instance, and initialize it to contain no points.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                     'type': 'MMatrixArray'}},
                                                 'args': [('arr',
                                                           'MMatrixArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nCreate a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MMatrixArray .',
                                                 'inArgs': ['arr'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MMatrixArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturn the number of matrices in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of matrices in the instance ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                     'set': [{'argInfo': {'element': {'doc': 'the element to be set ',
                                                                      'type': 'MMatrix'},
                                                          'index': {'doc': 'the index of the MMatrix to set',
                                                                    'type': 'uint'}},
                                              'args': [('element',
                                                        'MMatrix',
                                                        'in'),
                                                       ('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSet the matrix element at the specified index.',
                                              'inArgs': ['element',
                                                         'index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'element': ['&'],
                                                                 'index': ['unsigned']},
                                              'types': {'element': 'MMatrix',
                                                        'index': 'uint'}},
                                             {'argInfo': {'array': {'doc': 'the MMatrixArray containing the data to set into this instance',
                                                                    'type': 'MMatrixArray'}},
                                              'args': [('array',
                                                        'MMatrixArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSet the instance to contain the matrices defined in the given  MMatrixArray .',
                                              'inArgs': ['array'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['const',
                                                                           '&']},
                                              'types': {'array': 'MMatrixArray'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nFunction set type. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnMatrixAttribute': {'enums': {'Type': {'valueDocs': {'double': 'Matrix of double values.',
                                                          'float': 'Matrix of float values.',
                                                          'kDouble': 'Matrix of double values.',
                                                          'kFloat': 'Matrix of float values.'},
                                            'values': "Enum('Type', {'kFloat': 0, 'kDouble': 1})"}},
                         'invertibles': [('setDefault', 'getDefault')],
                         'methods': {'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nClass name. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'create': [{'argInfo': {'briefName': {'doc': 'The brief name of the attribute ',
                                                                           'type': 'MString'},
                                                             'fullName': {'doc': 'The full name of the attribute ',
                                                                          'type': 'MString'},
                                                             'matrixType': {'doc': 'Whether to create a matrix of floats or doubles ',
                                                                            'type': ('MFnMatrixAttribute',
                                                                                     'Type')}},
                                                 'args': [('fullName',
                                                           'MString',
                                                           'in'),
                                                          ('briefName',
                                                           'MString',
                                                           'in'),
                                                          ('matrixType',
                                                           ('MFnMatrixAttribute',
                                                            'Type'),
                                                           'in')],
                                                 'defaults': {'matrixType': ('MFnMatrixAttribute',
                                                                             'Type',
                                                                             'kDouble')},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreates a matrix attribute object.',
                                                 'inArgs': ['fullName',
                                                            'briefName',
                                                            'matrixType'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created Matrix attribute object.',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'briefName': ['const',
                                                                                  '&'],
                                                                    'fullName': ['const',
                                                                                 '&'],
                                                                    'matrixType': []},
                                                 'types': {'briefName': 'MString',
                                                           'fullName': 'MString',
                                                           'matrixType': ('MFnMatrixAttribute',
                                                                          'Type')}}],
                                     'getDefault': [{'argInfo': {'def': {'doc': 'returns the default matrix value',
                                                                         'type': 'MMatrix'}},
                                                     'args': [('def',
                                                               'MMatrix',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the default value for the attribute. Use this for getting the default value of a double matrix attribute.',
                                                     'inArgs': [],
                                                     'inverse': ('setDefault',
                                                                 False),
                                                     'outArgs': ['def'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'def': ['&']},
                                                     'types': {'def': 'MMatrix'}},
                                                    {'argInfo': {'def': {'doc': 'returns the default matrix value',
                                                                         'type': 'MFloatMatrix'}},
                                                     'args': [('def',
                                                               'MFloatMatrix',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the default value for the attribute. Use this for getting the default value of a float matrix attribute.',
                                                     'inArgs': [],
                                                     'inverse': ('setDefault',
                                                                 False),
                                                     'outArgs': ['def'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'def': ['&']},
                                                     'types': {'def': 'MFloatMatrix'}}],
                                     'setDefault': [{'argInfo': {'def': {'doc': 'matrix value',
                                                                         'type': 'MMatrix'}},
                                                     'args': [('def',
                                                               'MMatrix',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the default value for the attribute. Use this for setting the defaults of a double matrix attribute.',
                                                     'inArgs': ['def'],
                                                     'inverse': ('getDefault',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'def': ['const',
                                                                                '&']},
                                                     'types': {'def': 'MMatrix'}},
                                                    {'argInfo': {'def': {'doc': 'matrix value',
                                                                         'type': 'MFloatMatrix'}},
                                                     'args': [('def',
                                                               'MFloatMatrix',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the default value for the attribute. Use this for setting the defaults of a float matrix attribute.',
                                                     'inArgs': ['def'],
                                                     'inverse': ('getDefault',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'def': ['const',
                                                                                '&']},
                                                     'types': {'def': 'MFloatMatrix'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFunction set type. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {'Type': "Enum('Type', [('float', 0), ('kFloat', 0), ('double', 1), ('kDouble', 1)], multiKeys=True)"}},
  'MFnMatrixData': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it to the identity matrix. The result is not a transform matrix',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The new MObject ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}},
                                           {'argInfo': {'mat': {'doc': 'the MMatrix to copy the data from ',
                                                                'type': 'MMatrix'}},
                                            'args': [('mat',
                                                      'MMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it to the given matrix. The result is not a transform matrix.',
                                            'inArgs': ['mat'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The new MObject ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'mat': ['const',
                                                                       '&']},
                                            'types': {'mat': 'MMatrix'}},
                                           {'argInfo': {'transformation': {'doc': 'the MTransformationMatrix to copy the data from ',
                                                                           'type': 'MTransformationMatrix'}},
                                            'args': [('transformation',
                                                      'MTransformationMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it to the given transform matrix.',
                                            'inArgs': ['transformation'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The new MObject ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'transformation': ['const',
                                                                                  '&']},
                                            'types': {'transformation': 'MTransformationMatrix'}}],
                                'isTransformation': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nDetermine if the matrix held in this instance is a transform matrix.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'true if the instance holds a transform matrix, false otherwise ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                'matrix': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn a constant reference to the matrix held in this instance.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A const reference to the MMatrix ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MMatrix'},
                                            'returnType': 'MMatrix',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'set': [{'argInfo': {'transformation': {'doc': 'the MTransformationMatrix matrix to copy the data from',
                                                                        'type': 'MTransformationMatrix'}},
                                         'args': [('transformation',
                                                   'MTransformationMatrix',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSet this instance to hold a copy of the given transform matrix.',
                                         'inArgs': ['transformation'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'transformation': ['const',
                                                                               '&']},
                                         'types': {'transformation': 'MTransformationMatrix'}},
                                        {'argInfo': {'mat': {'doc': 'the MMatrix matrix to copy the data from',
                                                             'type': 'MMatrix'}},
                                         'args': [('mat',
                                                   'MMatrix',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSet this instance to hold a copy of the given matrix.',
                                         'inArgs': ['mat'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'mat': ['const',
                                                                    '&']},
                                         'types': {'mat': 'MMatrix'}}],
                                'transformation': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn a copy of the transform matrix held in this instance.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A copy of the MTransformationMatrix held in this instance ',
                                                                   'qualifiers': [],
                                                                   'type': 'MTransformationMatrix'},
                                                    'returnType': 'MTransformationMatrix',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {}},
  'MFnMesh': {'enums': {'BoolOperation': {'valueDocs': {'difference': 'Boolean difference.',
                                                        'intersection': 'Boolean intersection.',
                                                        'kDifference': 'Boolean difference.',
                                                        'kIntersection': 'Boolean intersection.',
                                                        'kUnion': 'Boolean union.',
                                                        'union': 'Boolean union.'},
                                          'values': "Enum('BoolOperation', {'kUnion': 1, 'kDifference': 2, 'kIntersection': 3})"},
                        'MColorRepresentation': {'valueDocs': {'RGB': 'Red, green and blue only.',
                                                               'RGBA': 'Red, green, blue and alpha.',
                                                               'alpha': 'Alpha only.',
                                                               'kAlpha': 'Alpha only.',
                                                               'kRGB': 'Red, green and blue only.',
                                                               'kRGBA': 'Red, green, blue and alpha.'},
                                                 'values': "Enum('MColorRepresentation', {'kAlpha': 1, 'kRGB': 3, 'kRGBA': 4})"},
                        'SplitPlacement': {'valueDocs': {'internalPoint': 'Split at a point within a face.',
                                                         'invalid': '',
                                                         'kInternalPoint': 'Split at a point within a face.',
                                                         'kInvalid': '',
                                                         'kOnEdge': 'Split at a position along an edge.',
                                                         'onEdge': 'Split at a position along an edge.'},
                                           'values': "Enum('SplitPlacement', {'kOnEdge': 0, 'kInternalPoint': 1, 'kInvalid': 2})"}},
              'invertibles': [('setCurrentUVSetName', 'currentUVSetName'),
                              ('setVertexColors', 'getVertexColors'),
                              ('setCreaseVertices', 'getCreaseVertices'),
                              ('setCheckSamePointTwice',
                               'getCheckSamePointTwice'),
                              ('setNormals', 'getNormals'),
                              ('setFloatBlindData', 'getFloatBlindData'),
                              ('setPoint', 'getPoint'),
                              ('setUVs', 'getUVs'),
                              ('setPinUVs', 'getPinUVs'),
                              ('setStringBlindData', 'getStringBlindData'),
                              ('setInvisibleFaces', 'getInvisibleFaces'),
                              ('setIntBlindData', 'getIntBlindData'),
                              ('setColor', 'getColor'),
                              ('setFaceVertexNormal',
                               'getFaceVertexNormal'),
                              ('setUV', 'getUV'),
                              ('setColors', 'getColors'),
                              ('setCreaseEdges', 'getCreaseEdges'),
                              ('setVertexNormal', 'getVertexNormal'),
                              ('setDisplayColors', 'displayColors'),
                              ('setBoolBlindData', 'getBoolBlindData'),
                              ('setCurrentColorSetName',
                               'currentColorSetName'),
                              ('setSmoothMeshDisplayOptions',
                               'getSmoothMeshDisplayOptions'),
                              ('setFaceVertexColors',
                               'getFaceVertexColors'),
                              ('setDoubleBlindData', 'getDoubleBlindData'),
                              ('setFaceVertexNormals',
                               'getFaceVertexNormals'),
                              ('setVertexNormals', 'getVertexNormals'),
                              ('setPoints', 'getPoints'),
                              ('setIsColorClamped', 'isColorClamped'),
                              ('setBinaryBlindData', 'getBinaryBlindData')],
              'methods': {'addHoles': [{'argInfo': {'faceIndex': {'doc': 'Index of the face to which to add holes. ',
                                                                  'type': 'int'},
                                                    'loopCounts': {'doc': 'Array of vertex loop counts. ',
                                                                   'type': 'MIntArray'},
                                                    'mergeVertices': {'doc': 'If true then if a vertex falls within pointTolerance of an existing vertex then the existing vertex is reused. ',
                                                                      'type': 'bool'},
                                                    'pointTolerance': {'doc': 'Specifies how close verticies have to be to before they are merged. This merging is only done if mergeVerticies is true.',
                                                                       'type': 'double'},
                                                    'vertexArray': {'doc': 'Array of ordered vertices that make up the polygon. ',
                                                                    'type': 'MPointArray'}},
                                        'args': [('faceIndex',
                                                  'int',
                                                  'in'),
                                                 ('vertexArray',
                                                  'MPointArray',
                                                  'in'),
                                                 ('loopCounts',
                                                  'MIntArray',
                                                  'in'),
                                                 ('mergeVertices',
                                                  'bool',
                                                  'in'),
                                                 ('pointTolerance',
                                                  'double',
                                                  'in')],
                                        'defaults': {'mergeVertices': True,
                                                     'pointTolerance': 1e-10},
                                        'deprecated': False,
                                        'doc': '\r\nAdds holes to a mesh polygon.',
                                        'inArgs': ['faceIndex',
                                                   'vertexArray',
                                                   'loopCounts',
                                                   'mergeVertices',
                                                   'pointTolerance'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'faceIndex': [],
                                                           'loopCounts': ['const',
                                                                          '&'],
                                                           'mergeVertices': [],
                                                           'pointTolerance': [],
                                                           'vertexArray': ['const',
                                                                           '&']},
                                        'types': {'faceIndex': 'int',
                                                  'loopCounts': 'MIntArray',
                                                  'mergeVertices': 'bool',
                                                  'pointTolerance': 'double',
                                                  'vertexArray': 'MPointArray'}}],
                          'addPolygon': [{'argInfo': {'mergeVertices': {'doc': 'If true then if a vertex falls within pointTolerance of an existing vertex then the existing vertex is reused. ',
                                                                        'type': 'bool'},
                                                      'parentOrOwner': {'doc': 'the DAG parent or kMeshData the new surface will belong to ',
                                                                        'type': 'MObject'},
                                                      'pointTolerance': {'doc': 'specifies how close verticies have to be to before they are merged. This merging is only done if mergeVerticies is true. ',
                                                                         'type': 'double'},
                                                      'vertexArray': {'doc': 'array of ordered vertices that make up the polygon ',
                                                                      'type': 'MPointArray'}},
                                          'args': [('vertexArray',
                                                    'MPointArray',
                                                    'in'),
                                                   ('mergeVertices',
                                                    'bool',
                                                    'in'),
                                                   ('pointTolerance',
                                                    'double',
                                                    'in'),
                                                   ('parentOrOwner',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {'mergeVertices': True,
                                                       'parentOrOwner': 'MObject::kNullObj',
                                                       'pointTolerance': 1e-10},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new polygon to this polygonal mesh.',
                                          'inArgs': ['vertexArray',
                                                     'mergeVertices',
                                                     'pointTolerance',
                                                     'parentOrOwner'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The transform if one is created, otherwise the geometry.',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'mergeVertices': [],
                                                             'parentOrOwner': [],
                                                             'pointTolerance': [],
                                                             'vertexArray': ['const',
                                                                             '&']},
                                          'types': {'mergeVertices': 'bool',
                                                    'parentOrOwner': 'MObject',
                                                    'pointTolerance': 'double',
                                                    'vertexArray': 'MPointArray'}},
                                         {'argInfo': {'faceIndex': {'doc': 'Index of the newly added polygon. ',
                                                                    'type': 'int'},
                                                      'mergeVertices': {'doc': 'If true then if a vertex falls within pointTolerance of an existing vertex then the existing vertex is reused. ',
                                                                        'type': 'bool'},
                                                      'parentOrOwner': {'doc': 'The DAG parent or kMeshData the new surface will belong to. ',
                                                                        'type': 'MObject'},
                                                      'pointTolerance': {'doc': 'Specifies how close verticies have to be to before they are merged. This merging is only done if mergeVerticies is true. ',
                                                                         'type': 'double'},
                                                      'vertexArray': {'doc': 'Array of ordered vertices that make up the polygon. ',
                                                                      'type': 'MPointArray'}},
                                          'args': [('vertexArray',
                                                    'MPointArray',
                                                    'in'),
                                                   ('faceIndex',
                                                    'int',
                                                    'out'),
                                                   ('mergeVertices',
                                                    'bool',
                                                    'in'),
                                                   ('pointTolerance',
                                                    'double',
                                                    'in'),
                                                   ('parentOrOwner',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {'mergeVertices': True,
                                                       'parentOrOwner': 'MObject::kNullObj',
                                                       'pointTolerance': 1e-10},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new polygon to this polygonal mesh. Return an index of the created polygon.',
                                          'inArgs': ['vertexArray',
                                                     'mergeVertices',
                                                     'pointTolerance',
                                                     'parentOrOwner'],
                                          'outArgs': ['faceIndex'],
                                          'returnInfo': {'doc': 'The transform if one is created, otherwise the geometry.',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'faceIndex': ['&'],
                                                             'mergeVertices': [],
                                                             'parentOrOwner': [],
                                                             'pointTolerance': [],
                                                             'vertexArray': ['const',
                                                                             '&']},
                                          'types': {'faceIndex': 'int',
                                                    'mergeVertices': 'bool',
                                                    'parentOrOwner': 'MObject',
                                                    'pointTolerance': 'double',
                                                    'vertexArray': 'MPointArray'}},
                                         {'argInfo': {'faceIndex': {'doc': 'Index of the newly added polygon. ',
                                                                    'type': 'int'},
                                                      'loopCounts': {'doc': 'Array of vertex loop counts. ',
                                                                     'type': 'MIntArray'},
                                                      'mergeVertices': {'doc': 'If true then if a vertex falls within pointTolerance of an existing vertex then the existing vertex is reused. ',
                                                                        'type': 'bool'},
                                                      'parentOrOwner': {'doc': 'The DAG parent or kMeshData the new surface will belong to. ',
                                                                        'type': 'MObject'},
                                                      'pointTolerance': {'doc': 'Specifies how close verticies have to be to before they are merged. This merging is only done if mergeVerticies is true. ',
                                                                         'type': 'double'},
                                                      'vertexArray': {'doc': 'Array of ordered vertices that make up the polygon. ',
                                                                      'type': 'MPointArray'}},
                                          'args': [('vertexArray',
                                                    'MPointArray',
                                                    'in'),
                                                   ('loopCounts',
                                                    'MIntArray',
                                                    'in'),
                                                   ('faceIndex',
                                                    'int',
                                                    'out'),
                                                   ('mergeVertices',
                                                    'bool',
                                                    'in'),
                                                   ('pointTolerance',
                                                    'double',
                                                    'in'),
                                                   ('parentOrOwner',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {'mergeVertices': True,
                                                       'parentOrOwner': 'MObject::kNullObj',
                                                       'pointTolerance': 1e-10},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new polygon to this polygonal mesh. Return an index of the created polygon.',
                                          'inArgs': ['vertexArray',
                                                     'loopCounts',
                                                     'mergeVertices',
                                                     'pointTolerance',
                                                     'parentOrOwner'],
                                          'outArgs': ['faceIndex'],
                                          'returnInfo': {'doc': 'The transform if one is created, otherwise the geometry.',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'faceIndex': ['&'],
                                                             'loopCounts': ['const',
                                                                            '&'],
                                                             'mergeVertices': [],
                                                             'parentOrOwner': [],
                                                             'pointTolerance': [],
                                                             'vertexArray': ['const',
                                                                             '&']},
                                          'types': {'faceIndex': 'int',
                                                    'loopCounts': 'MIntArray',
                                                    'mergeVertices': 'bool',
                                                    'parentOrOwner': 'MObject',
                                                    'pointTolerance': 'double',
                                                    'vertexArray': 'MPointArray'}}],
                          'allIntersections': [{'argInfo': {'accelParams': {'doc': 'optional acceleration parameters. ',
                                                                            'type': 'MMeshIsectAccelParams'},
                                                            'faceIds': {'doc': '(see above) if non-nullptr, describes a subset of faces to consider for intersection. ',
                                                                        'type': 'MIntArray'},
                                                            'hitBary1s': {'doc': "if non-nullptr, points to an array that will be filled in with the first barycentric coordinates of the hit points within the triangles defined by hitFaces and *hitTriangles. For the i'th hit, If v1, v2, and v3 are the vertices of that triangle, then the barycentric coordinates are such that hitPoint[i] = (*hitBary1s)[i]*v1 + (*hitBary2s)[i]*v2 + (1-(*hitBary1s)[i]-(*hitBary2s)[i])*v3; If no hits were found, the referenced value will not be modified, ",
                                                                          'type': 'MFloatArray'},
                                                            'hitBary2s': {'doc': 'if non-nullptr, points to an array that will be filled in with the second barycentric coordinates of the hit points within the triangles defined by hitFaces and *hitTriangles. If no hits were found, the referenced values will not be modified, ',
                                                                          'type': 'MFloatArray'},
                                                            'hitFaces': {'doc': 'if non-nullptr, points to an array that will be filled in with the face ids of the hit points, if any were found. If no hits were found, the referenced values will not be modified. ',
                                                                         'type': 'MIntArray'},
                                                            'hitPoints': {'doc': 'an array that receives the 3d coordinates of the intersections, in the space specified by the space parameter. ',
                                                                          'type': 'MFloatPointArray'},
                                                            'hitRayParams': {'doc': "if non-nullptr, points to an array that will be filled in with the parametric distances along the ray to the hit points, if any were found. That is, for the i'th hit, hitPoints[i] = raySource+(*hitRayParams[i])*rayDirection. If no hit was found, the referenced values will not be modified. ",
                                                                             'type': 'MFloatArray'},
                                                            'hitTriangles': {'doc': 'if non-nullptr, points to an array that will be filled in with the 0-based indices of the triangles that were hit within the faces given by *hitFaces. If no hits were found, the referenced values will not be modified, ',
                                                                             'type': 'MIntArray'},
                                                            'idsSorted': {'doc': 'should be true if the faceIds or faceIds/triIds arrays are properly sorted into ascending order. For face-triangle pairs, the arrays must be sorted by ascending face ids, then by ascending triangle ids within each face. The routine sortIntersectionFaceTriIds() can be used to perform this task. It is not important to sort ids unless an acceleration structure is being used. When using an acceleration structure in conjunction with a limited set of faces or face-triangles, it is ESSENTIAL to sort the indices, otherwise performance will be severely degraded. ',
                                                                          'type': 'bool'},
                                                            'maxParam': {'doc': 'specifies the maximum radius within which hits will be considered. This radius is specified as a multiple of the length of the rayDirection vector, so any hits beyond raySource+maxParam*rayDirection will not be considered. This value must be positive. ',
                                                                         'type': 'float'},
                                                            'rayDirection': {'doc': 'Direction of the ray ',
                                                                             'type': 'MFloatVector'},
                                                            'raySource': {'doc': 'Starting point for the ray ',
                                                                          'type': 'MFloatPoint'},
                                                            'sortHits': {'doc': 'if true, then hits will be sorted in ascending ray-parametric order, so hits behind the raySource will be first (if testBothDirections is true), moving proceeding closer to the raySource, followed by hits in front of the raySource, proceeding by increasing distance from the raySource. If false, hits will be presented in no particular order in the return arrays. ',
                                                                         'type': 'bool'},
                                                            'space': {'doc': 'specifies the space in which raySource and rayDirection are specified, as well as the space in which the hit point will be returned. ',
                                                                      'type': ('MSpace',
                                                                               'Space')},
                                                            'testBothDirections': {'doc': 'specifies that hits in the negative rayDirection should also be considered. The maxParam value still applies to limit the search radius, which means that if testBothDirections is true, then only hits that lie between raySource-maxParam*rayDirection and raySource+maxParam*rayDirection will be considered. ',
                                                                                   'type': 'bool'},
                                                            'tolerance': {'doc': 'numerical tolerance for the intersection operation. For numerical reasons, it is wise to allow the intersection routine to consider hits that lie a tiny bit outside mesh triangles. This parameter defines how close a ray has to be to hitting a triangle in order for a hit to register. Obviously, hits within the triangle are always considered, but we also consider hits that are up to a distance of tol*edgeLength away from the triangle, where "edgeLength" is the length of the edge of the triangle that is closest to the ray. This tolerance value is also used to collapse multiple nearly-identical hits that may arise due to numerical imprecision when a ray passes extremely close to a mesh vertex. Any two hits that are less than tol multiplied by the length of rayDirection apart will be considered the same hit, and treated interchangeably. ',
                                                                          'type': 'float'},
                                                            'triIds': {'doc': '(see above) if non-nullptr, then along with faceIds describes a set of face-triangles to consider for intersection. If triIds is non-nullptr, then faceIds must be non-nullptr as well, otherwise an error will be generated. ',
                                                                       'type': 'MIntArray'}},
                                                'args': [('raySource',
                                                          'MFloatPoint',
                                                          'in'),
                                                         ('rayDirection',
                                                          'MFloatVector',
                                                          'in'),
                                                         ('faceIds',
                                                          'MIntArray',
                                                          'in'),
                                                         ('triIds',
                                                          'MIntArray',
                                                          'in'),
                                                         ('idsSorted',
                                                          'bool',
                                                          'in'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in'),
                                                         ('maxParam',
                                                          'float',
                                                          'in'),
                                                         ('testBothDirections',
                                                          'bool',
                                                          'in'),
                                                         ('accelParams',
                                                          'MMeshIsectAccelParams',
                                                          'in'),
                                                         ('sortHits',
                                                          'bool',
                                                          'in'),
                                                         ('hitPoints',
                                                          'MFloatPointArray',
                                                          'out'),
                                                         ('hitRayParams',
                                                          'MFloatArray',
                                                          'out'),
                                                         ('hitFaces',
                                                          'MIntArray',
                                                          'out'),
                                                         ('hitTriangles',
                                                          'MIntArray',
                                                          'out'),
                                                         ('hitBary1s',
                                                          'MFloatArray',
                                                          'out'),
                                                         ('hitBary2s',
                                                          'MFloatArray',
                                                          'out'),
                                                         ('tolerance',
                                                          'float',
                                                          'in')],
                                                'defaults': {'tolerance': 1e-06},
                                                'deprecated': False,
                                                'doc': '\r\nFinds all intersections of a ray starting at raySource and travelling in rayDirection with the mesh. If faceIds is non-nullptr and triIds is nullptr, then only the faces specified by faceIds will be considered for intersection. If both faceIds and triIds are non-nullptr, then each pair of entries will be taken as a (face,triangle) pair to be considered for intersection, where triangles are numbered on each face starting from 0. Thus, the face-triangle pair (10,0) means the first triangle on face 10. If both faceIds and triIds are nullptr, then all face-triangles in the mesh will be considered.',
                                                'inArgs': ['raySource',
                                                           'rayDirection',
                                                           'faceIds',
                                                           'triIds',
                                                           'idsSorted',
                                                           'space',
                                                           'maxParam',
                                                           'testBothDirections',
                                                           'accelParams',
                                                           'sortHits',
                                                           'tolerance'],
                                                'outArgs': ['hitPoints',
                                                            'hitRayParams',
                                                            'hitFaces',
                                                            'hitTriangles',
                                                            'hitBary1s',
                                                            'hitBary2s'],
                                                'returnInfo': {'doc': ' true The given ray intersects the mesh, and the intersections of the ray with the mesh are given by the values returned in hitPoints.  false The given ray does not intersect this mesh  ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'accelParams': ['*'],
                                                                   'faceIds': ['const',
                                                                               '*'],
                                                                   'hitBary1s': ['*'],
                                                                   'hitBary2s': ['*'],
                                                                   'hitFaces': ['*'],
                                                                   'hitPoints': ['&'],
                                                                   'hitRayParams': ['*'],
                                                                   'hitTriangles': ['*'],
                                                                   'idsSorted': [],
                                                                   'maxParam': [],
                                                                   'rayDirection': ['const',
                                                                                    '&'],
                                                                   'raySource': ['const',
                                                                                 '&'],
                                                                   'sortHits': [],
                                                                   'space': [],
                                                                   'testBothDirections': [],
                                                                   'tolerance': [],
                                                                   'triIds': ['const',
                                                                              '*']},
                                                'types': {'accelParams': 'MMeshIsectAccelParams',
                                                          'faceIds': 'MIntArray',
                                                          'hitBary1s': 'MFloatArray',
                                                          'hitBary2s': 'MFloatArray',
                                                          'hitFaces': 'MIntArray',
                                                          'hitPoints': 'MFloatPointArray',
                                                          'hitRayParams': 'MFloatArray',
                                                          'hitTriangles': 'MIntArray',
                                                          'idsSorted': 'bool',
                                                          'maxParam': 'float',
                                                          'rayDirection': 'MFloatVector',
                                                          'raySource': 'MFloatPoint',
                                                          'sortHits': 'bool',
                                                          'space': ('MSpace',
                                                                    'Space'),
                                                          'testBothDirections': 'bool',
                                                          'tolerance': 'float',
                                                          'triIds': 'MIntArray'}}],
                          'anyIntersection': [{'argInfo': {'accelParams': {'doc': 'optional acceleration parameters. ',
                                                                           'type': 'MMeshIsectAccelParams'},
                                                           'faceIds': {'doc': '(see above) if non-nullptr, describes a subset of faces to consider for intersection. ',
                                                                       'type': 'MIntArray'},
                                                           'hitBary1': {'doc': 'if non-nullptr, points to a value that will be filled in with the first barycentric coordinate of the hit point within the triangle defined by hitFace and *hitTriangle. If v1, v2, and v3 are the vertices of that triangle, then the barycentric coordinates are such that hitPoint = (*hitBary1)*v1 + (*hitBary2)*v2 + (1-*hitBary1-*hitBary2)*v3; If no hit was found, the referenced value will not be modified, ',
                                                                        'type': 'float'},
                                                           'hitBary2': {'doc': 'if non-nullptr, points to a value that will be filled in with the second barycentric coordinate of the hit point within the triangle defined by hitFace and *hitTriangle. If no hit was found, the referenced value will not be modified, ',
                                                                        'type': 'float'},
                                                           'hitFace': {'doc': 'if non-nullptr, points to a value that will be filled in with the face id of the hit point, if one was found. If no hit was found, the referenced value will not be modified. ',
                                                                       'type': 'int'},
                                                           'hitPoint': {'doc': 'receives the 3d coordinates of the intersection, in the space specified by the space parameter. ',
                                                                        'type': 'MFloatPoint'},
                                                           'hitRayParam': {'doc': 'if non-nullptr, points to a value that will be filled in with the parametric distance along the ray to the hit point, if one was found. That is, hitPoint = raySource+(*hitRayParam)*rayDirection. If no hit was found, the referenced value will not be modified. ',
                                                                           'type': 'float'},
                                                           'hitTriangle': {'doc': 'if non-nullptr, points to a value that will be filled in with the 0-based index of the triangle that was hit within the face given by *hitFace. If no hit was found, the referenced value will not be modified, ',
                                                                           'type': 'int'},
                                                           'idsSorted': {'doc': 'should be true if the faceIds or faceIds/triIds arrays are properly sorted into ascending order. For face-triangle pairs, the arrays must be sorted by ascending face ids, then by ascending triangle ids within each face. The routine sortIntersectionFaceTriIds() can be used to perform this task. It is not important to sort ids unless an acceleration structure is being used. When using an acceleration structure in conjunction with a limited set of faces or face-triangles, it is ESSENTIAL to sort the indices, otherwise performance will be severely degraded. ',
                                                                         'type': 'bool'},
                                                           'maxParam': {'doc': 'specifies the maximum radius within which hits will be considered. This radius is specified as a multiple of the length of the rayDirection vector, so any hits beyond raySource+maxParam*rayDirection will not be considered. This value must be positive. ',
                                                                        'type': 'float'},
                                                           'rayDirection': {'doc': 'Direction of the ray ',
                                                                            'type': 'MFloatVector'},
                                                           'raySource': {'doc': 'Starting point for the ray ',
                                                                         'type': 'MFloatPoint'},
                                                           'space': {'doc': 'specifies the space in which raySource and rayDirection are specified, as well as the space in which the hit point will be returned. ',
                                                                     'type': ('MSpace',
                                                                              'Space')},
                                                           'testBothDirections': {'doc': 'specifies that hits in the negative rayDirection should also be considered. The maxParam value still applies to limit the search radius, which means that if testBothDirections is true, then only hits that lie between raySource-maxParam*rayDirection and raySource+maxParam*rayDirection will be considered. ',
                                                                                  'type': 'bool'},
                                                           'tolerance': {'doc': 'numerical tolerance for the intersection operation. For numerical reasons, it is wise to allow the intersection routine to consider hits that lie a tiny bit outside mesh triangles. This parameter defines how close a ray has to be to hitting a triangle in order for a hit to register. Obviously, hits within the triangle are always considered, but we also consider hits that are up to a distance of tol*edgeLength away from the triangle, where "edgeLength" is the length of the edge of the triangle that is closest to the ray. This tolerance value is also used to collapse multiple nearly-identical hits that may arise due to numerical imprecision when a ray passes extremely close to a mesh vertex. Any two hits that are less than tol multiplied by the length of rayDirection apart will be considered the same hit, and treated interchangeably. ',
                                                                         'type': 'float'},
                                                           'triIds': {'doc': '(see above) if non-nullptr, then along with faceIds describes a set of face-triangles to consider for intersection. If triIds is non-nullptr, then faceIds must be non-nullptr as well, otherwise an error will be generated. ',
                                                                      'type': 'MIntArray'}},
                                               'args': [('raySource',
                                                         'MFloatPoint',
                                                         'in'),
                                                        ('rayDirection',
                                                         'MFloatVector',
                                                         'in'),
                                                        ('faceIds',
                                                         'MIntArray',
                                                         'in'),
                                                        ('triIds',
                                                         'MIntArray',
                                                         'in'),
                                                        ('idsSorted',
                                                         'bool',
                                                         'in'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in'),
                                                        ('maxParam',
                                                         'float',
                                                         'in'),
                                                        ('testBothDirections',
                                                         'bool',
                                                         'in'),
                                                        ('accelParams',
                                                         'MMeshIsectAccelParams',
                                                         'in'),
                                                        ('hitPoint',
                                                         'MFloatPoint',
                                                         'out'),
                                                        ('hitRayParam',
                                                         'float',
                                                         'out'),
                                                        ('hitFace',
                                                         'int',
                                                         'out'),
                                                        ('hitTriangle',
                                                         'int',
                                                         'out'),
                                                        ('hitBary1',
                                                         'float',
                                                         'out'),
                                                        ('hitBary2',
                                                         'float',
                                                         'out'),
                                                        ('tolerance',
                                                         'float',
                                                         'in')],
                                               'defaults': {'tolerance': 1e-06},
                                               'deprecated': False,
                                               'doc': '\r\nFinds any intersection of a ray starting at raySource and travelling in rayDirection with the mesh. If faceIds is non-nullptr and triIds is nullptr, then only the faces specified by faceIds will be considered for intersection. If both faceIds and triIds are non-nullptr, then each pair of entries will be taken as a (face,triangle) pair to be considered for intersection, where triangles are numbered on each face starting from 0. Thus, the face-triangle pair (10,0) means the first triangle on face 10. If both faceIds and triIds are nullptr, then all face-triangles in the mesh will be considered.',
                                               'inArgs': ['raySource',
                                                          'rayDirection',
                                                          'faceIds',
                                                          'triIds',
                                                          'idsSorted',
                                                          'space',
                                                          'maxParam',
                                                          'testBothDirections',
                                                          'accelParams',
                                                          'tolerance'],
                                               'outArgs': ['hitPoint',
                                                           'hitRayParam',
                                                           'hitFace',
                                                           'hitTriangle',
                                                           'hitBary1',
                                                           'hitBary2'],
                                               'returnInfo': {'doc': ' true The given ray intersects the mesh, and the found intersection of the ray with the mesh is given by the value returned in hitPoint.  false The given ray does not intersect this mesh  ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'accelParams': ['*'],
                                                                  'faceIds': ['const',
                                                                              '*'],
                                                                  'hitBary1': ['*'],
                                                                  'hitBary2': ['*'],
                                                                  'hitFace': ['*'],
                                                                  'hitPoint': ['&'],
                                                                  'hitRayParam': ['*'],
                                                                  'hitTriangle': ['*'],
                                                                  'idsSorted': [],
                                                                  'maxParam': [],
                                                                  'rayDirection': ['const',
                                                                                   '&'],
                                                                  'raySource': ['const',
                                                                                '&'],
                                                                  'space': [],
                                                                  'testBothDirections': [],
                                                                  'tolerance': [],
                                                                  'triIds': ['const',
                                                                             '*']},
                                               'types': {'accelParams': 'MMeshIsectAccelParams',
                                                         'faceIds': 'MIntArray',
                                                         'hitBary1': 'float',
                                                         'hitBary2': 'float',
                                                         'hitFace': 'int',
                                                         'hitPoint': 'MFloatPoint',
                                                         'hitRayParam': 'float',
                                                         'hitTriangle': 'int',
                                                         'idsSorted': 'bool',
                                                         'maxParam': 'float',
                                                         'rayDirection': 'MFloatVector',
                                                         'raySource': 'MFloatPoint',
                                                         'space': ('MSpace',
                                                                   'Space'),
                                                         'testBothDirections': 'bool',
                                                         'tolerance': 'float',
                                                         'triIds': 'MIntArray'}}],
                          'assignColor': [{'argInfo': {'colorId': {'doc': 'The color entry from the color list that will be mapped ',
                                                                   'type': 'int'},
                                                       'colorSet': {'doc': 'Color set to work with',
                                                                    'type': 'MString'},
                                                       'polygonId': {'doc': 'The polygon (face) to map to ',
                                                                     'type': 'int'},
                                                       'vertexIndex': {'doc': 'The face-relative (local) vertex id of the polygon to map to ',
                                                                       'type': 'int'}},
                                           'args': [('polygonId',
                                                     'int',
                                                     'in'),
                                                    ('vertexIndex',
                                                     'int',
                                                     'in'),
                                                    ('colorId',
                                                     'int',
                                                     'in'),
                                                    ('colorSet',
                                                     'MString',
                                                     'in')],
                                           'defaults': {'colorSet': None},
                                           'deprecated': False,
                                           'doc': '\r\nMaps a color value to a specified vertex of a polygon.',
                                           'inArgs': ['polygonId',
                                                      'vertexIndex',
                                                      'colorId',
                                                      'colorSet'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'colorId': [],
                                                              'colorSet': ['const',
                                                                           '*'],
                                                              'polygonId': [],
                                                              'vertexIndex': []},
                                           'types': {'colorId': 'int',
                                                     'colorSet': 'MString',
                                                     'polygonId': 'int',
                                                     'vertexIndex': 'int'}}],
                          'assignColors': [{'argInfo': {'colorIds': {'doc': 'The color indices to be mapped to each polygon-vertex ',
                                                                     'type': 'MIntArray'},
                                                        'colorSet': {'doc': 'Color set to work with',
                                                                     'type': 'MString'}},
                                            'args': [('colorIds',
                                                      'MIntArray',
                                                      'in'),
                                                     ('colorSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'colorSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nThis method maps all colors for the mesh. The setColor/setColors method is used to create a color table for the mesh. After the table is created, this method is used to map those values to each polygon on a per-vertex basis. The setColor/setColors method should be called before the assignColors method.',
                                            'inArgs': ['colorIds',
                                                       'colorSet'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'colorIds': ['const',
                                                                            '&'],
                                                               'colorSet': ['const',
                                                                            '*']},
                                            'types': {'colorIds': 'MIntArray',
                                                      'colorSet': 'MString'}}],
                          'assignUV': [{'argInfo': {'polygonId': {'doc': 'The polygon (face) to map to ',
                                                                  'type': 'int'},
                                                    'uvId': {'doc': 'The uv entry from the uv list that will be mapped ',
                                                             'type': 'int'},
                                                    'uvSet': {'doc': 'UV set to work with',
                                                              'type': 'MString'},
                                                    'vertexIndex': {'doc': 'The face-relative (local) vertex id of the polygon to map to ',
                                                                    'type': 'int'}},
                                        'args': [('polygonId',
                                                  'int',
                                                  'in'),
                                                 ('vertexIndex',
                                                  'int',
                                                  'in'),
                                                 ('uvId', 'int', 'in'),
                                                 ('uvSet',
                                                  'MString',
                                                  'in')],
                                        'defaults': {'uvSet': None},
                                        'deprecated': False,
                                        'doc': '\r\nMaps a texture coordinate to a specified vertex of a polygon.',
                                        'inArgs': ['polygonId',
                                                   'vertexIndex',
                                                   'uvId',
                                                   'uvSet'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'polygonId': [],
                                                           'uvId': [],
                                                           'uvSet': ['const',
                                                                     '*'],
                                                           'vertexIndex': []},
                                        'types': {'polygonId': 'int',
                                                  'uvId': 'int',
                                                  'uvSet': 'MString',
                                                  'vertexIndex': 'int'}}],
                          'assignUVs': [{'argInfo': {'uvCounts': {'doc': 'The uv counts for each polygon (face) in the mesh ',
                                                                  'type': 'MIntArray'},
                                                     'uvIds': {'doc': 'The uv indices to be mapped to each polygon-vertex ',
                                                               'type': 'MIntArray'},
                                                     'uvSet': {'doc': 'UV set to work with',
                                                               'type': 'MString'}},
                                         'args': [('uvCounts',
                                                   'MIntArray',
                                                   'in'),
                                                  ('uvIds',
                                                   'MIntArray',
                                                   'in'),
                                                  ('uvSet',
                                                   'MString',
                                                   'in')],
                                         'defaults': {'uvSet': None},
                                         'deprecated': False,
                                         'doc': '\r\nThis method maps all texture coordinates for the mesh. The setUV/setUVs method is used to create the texture coordinate table for the mesh. After the table is created, this method is used to map those values to each polygon on a per-vertex basis. The setUV/setUVs method should be called before the assignUVs method.',
                                         'inArgs': ['uvCounts',
                                                    'uvIds',
                                                    'uvSet'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'uvCounts': ['const',
                                                                         '&'],
                                                            'uvIds': ['const',
                                                                      '&'],
                                                            'uvSet': ['const',
                                                                      '*']},
                                         'types': {'uvCounts': 'MIntArray',
                                                   'uvIds': 'MIntArray',
                                                   'uvSet': 'MString'}}],
                          'autoUniformGridParams': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nCreates a  MMeshIsectAccelParams  configuration object that can be passed to several of the geometric query methods on  MFnMesh  to speed up their operation. For example, the  MFnMesh  closest point and intersection methods can optionally make use of this object.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Intersection accelerator object. ',
                                                                    'qualifiers': [],
                                                                    'type': 'MMeshIsectAccelParams'},
                                                     'returnType': 'MMeshIsectAccelParams',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                          'binaryBlindDataComponentId': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                                   'type': 'MString'},
                                                                      'blindDataId': {'doc': 'The blind data id to check for ',
                                                                                      'type': 'int'},
                                                                      'compID': {'doc': 'The component to get for blind data on When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                                 'type': 'int'},
                                                                      'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                                   'type': ('MFn',
                                                                                            'Type')}},
                                                          'args': [('compID',
                                                                    'int',
                                                                    'in'),
                                                                   ('compType',
                                                                    ('MFn',
                                                                     'Type'),
                                                                    'in'),
                                                                   ('blindDataId',
                                                                    'int',
                                                                    'in'),
                                                                   ('attrName',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGet the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.',
                                                          'inArgs': ['compID',
                                                                     'compType',
                                                                     'blindDataId',
                                                                     'attrName'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The data item.',
                                                                         'qualifiers': [],
                                                                         'type': 'MString'},
                                                          'returnType': 'MString',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'attrName': [],
                                                                             'blindDataId': [],
                                                                             'compID': [],
                                                                             'compType': []},
                                                          'types': {'attrName': 'MString',
                                                                    'blindDataId': 'int',
                                                                    'compID': 'int',
                                                                    'compType': ('MFn',
                                                                                 'Type')}}],
                          'booleanOp': [{'argInfo': {'mesh1': {'doc': 'The first mesh in the boolean operation ',
                                                               'type': 'MFnMesh'},
                                                     'mesh2': {'doc': 'The second mesh in the boolean operation',
                                                               'type': 'MFnMesh'},
                                                     'op': {'doc': 'Operation to perform (kUnion, kDifference or kIntersection) ',
                                                            'type': ('MFnMesh',
                                                                     'BoolOperation')}},
                                         'args': [('op',
                                                   ('MFnMesh',
                                                    'BoolOperation'),
                                                   'in'),
                                                  ('mesh1',
                                                   'MFnMesh',
                                                   'in'),
                                                  ('mesh2',
                                                   'MFnMesh',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': True,
                                         'doc': '\n This method is obsolete. \n',
                                         'inArgs': ['op',
                                                    'mesh1',
                                                    'mesh2'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'mesh1': ['&'],
                                                            'mesh2': ['&'],
                                                            'op': []},
                                         'types': {'mesh1': 'MFnMesh',
                                                   'mesh2': 'MFnMesh',
                                                   'op': ('MFnMesh',
                                                          'BoolOperation')}}],
                          'booleanOps': [{'argInfo': {'meshes': {'doc': 'The meshes for the boolean operation ',
                                                                 'type': 'MObjectArray'},
                                                      'op': {'doc': 'Operation to perform (kUnion, kDifference or kIntersection) ',
                                                             'type': ('MFnMesh',
                                                                      'BoolOperation')},
                                                      'useLegacy': {'doc': "Flag to indicate if Maya's legacy boolean algorithm should be used. The legacy algorithm produces lower quality results, and should only be used when required to match boolean results from versions of Maya prior to 2015.",
                                                                    'type': 'bool'}},
                                          'args': [('op',
                                                    ('MFnMesh',
                                                     'BoolOperation'),
                                                    'in'),
                                                   ('meshes',
                                                    'MObjectArray',
                                                    'in'),
                                                   ('useLegacy',
                                                    'bool',
                                                    'out')],
                                          'defaults': {'useLegacy': False},
                                          'deprecated': False,
                                          'doc': '\r\nComputes the boolean between multiple meshes. The result is stored in the current  MFnMesh  instance. The current instance must point to a valid mesh, which can be empty. Such a mesh can result from using  MFnMesh::create()  for example.',
                                          'inArgs': ['op', 'meshes'],
                                          'outArgs': ['useLegacy'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'meshes': ['const',
                                                                        '&'],
                                                             'op': [],
                                                             'useLegacy': []},
                                          'types': {'meshes': 'MObjectArray',
                                                    'op': ('MFnMesh',
                                                           'BoolOperation'),
                                                    'useLegacy': 'bool'}}],
                          'cachedIntersectionAcceleratorInfo': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nRetrieves a string that describes the intersection acceleration structure for this object, if any. The string is formatted similar to:',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'The description string ',
                                                                                'qualifiers': [],
                                                                                'type': 'MString'},
                                                                 'returnType': 'MString',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                                 'types': {}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nClass name. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'cleanupEdgeSmoothing': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "\r\nThis method updates the mesh after setEdgeSmoothing has been done. This should be called only once, after all the desired edges have been had their soothing set. If you don't call this method, the normals may not be correct, and the object will look odd in shaded mode.",
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                          'clearBlindData': [{'argInfo': {'attrName': {'doc': 'Attribute name',
                                                                       'type': 'MString'},
                                                          'blindDataId': {'doc': 'The id for the blind data to be cleared ',
                                                                          'type': 'int'},
                                                          'compID': {'doc': 'The component to clear the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                     'type': 'int'},
                                                          'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                       'type': ('MFn',
                                                                                'Type')}},
                                              'args': [('compID',
                                                        'int',
                                                        'in'),
                                                       ('compType',
                                                        ('MFn', 'Type'),
                                                        'in'),
                                                       ('blindDataId',
                                                        'int',
                                                        'in'),
                                                       ('attrName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDelete a value for a binary blind data attribute on a particular componenr',
                                              'inArgs': ['compID',
                                                         'compType',
                                                         'blindDataId',
                                                         'attrName'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'attrName': [],
                                                                 'blindDataId': [],
                                                                 'compID': [],
                                                                 'compType': []},
                                              'types': {'attrName': 'MString',
                                                        'blindDataId': 'int',
                                                        'compID': 'int',
                                                        'compType': ('MFn',
                                                                     'Type')}},
                                             {'argInfo': {'attrName': {'doc': 'The attribute to clear the blind data for',
                                                                       'type': 'MString'},
                                                          'blindDataId': {'doc': 'The id for the blind data to be cleared ',
                                                                          'type': 'int'},
                                                          'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                       'type': ('MFn',
                                                                                'Type')}},
                                              'args': [('compType',
                                                        ('MFn', 'Type'),
                                                        'in'),
                                                       ('blindDataId',
                                                        'int',
                                                        'in'),
                                                       ('attrName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDelete the values for the given attribute on the given binary blind data type from all components of the given type.',
                                              'inArgs': ['compType',
                                                         'blindDataId',
                                                         'attrName'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'attrName': [],
                                                                 'blindDataId': [],
                                                                 'compType': []},
                                              'types': {'attrName': 'MString',
                                                        'blindDataId': 'int',
                                                        'compType': ('MFn',
                                                                     'Type')}},
                                             {'argInfo': {'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent',
                                                                       'type': ('MFn',
                                                                                'Type')}},
                                              'args': [('compType',
                                                        ('MFn', 'Type'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDelete all blind data from components of the given type, e.g. all edges from a particular component.',
                                              'inArgs': ['compType'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'compType': []},
                                              'types': {'compType': ('MFn',
                                                                     'Type')}},
                                             {'argInfo': {'blindDataId': {'doc': 'The id for the blind data to be cleared',
                                                                          'type': 'int'},
                                                          'compID': {'doc': 'The component to clear the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                     'type': 'int'},
                                                          'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                       'type': ('MFn',
                                                                                'Type')}},
                                              'args': [('compID',
                                                        'int',
                                                        'in'),
                                                       ('compType',
                                                        ('MFn', 'Type'),
                                                        'in'),
                                                       ('blindDataId',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDelete the values for a binary blind data type (all its attributes) from a particular component.',
                                              'inArgs': ['compID',
                                                         'compType',
                                                         'blindDataId'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'blindDataId': [],
                                                                 'compID': [],
                                                                 'compType': []},
                                              'types': {'blindDataId': 'int',
                                                        'compID': 'int',
                                                        'compType': ('MFn',
                                                                     'Type')}},
                                             {'argInfo': {'blindDataId': {'doc': 'The id for the blind data to be cleared',
                                                                          'type': 'int'},
                                                          'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                       'type': ('MFn',
                                                                                'Type')}},
                                              'args': [('compType',
                                                        ('MFn', 'Type'),
                                                        'in'),
                                                       ('blindDataId',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDelete the values for a binary blind data type (all its attributes) from all components of the given type.',
                                              'inArgs': ['compType',
                                                         'blindDataId'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'blindDataId': [],
                                                                 'compType': []},
                                              'types': {'blindDataId': 'int',
                                                        'compType': ('MFn',
                                                                     'Type')}}],
                          'clearColors': [{'argInfo': {'colorSet': {'doc': 'Color set to work with',
                                                                    'type': 'MString'}},
                                           'args': [('colorSet',
                                                     'MString',
                                                     'in')],
                                           'defaults': {'colorSet': None},
                                           'deprecated': False,
                                           'doc': '\r\nThis method clears out all color for the mesh, and leaves behind an empty color set.',
                                           'inArgs': ['colorSet'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'colorSet': ['const',
                                                                           '*']},
                                           'types': {'colorSet': 'MString'}}],
                          'clearGlobalIntersectionAcceleratorInfo': [{'argInfo': {},
                                                                      'args': [],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\r\nAs described above, clears the "total count", "total build time", and "peak memory" fields from the information string returned by  globalIntersectionAcceleratorsInfo() . It will not cause information about currently existing accelerators to be lost. \r\n',
                                                                      'inArgs': [],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': None},
                                                                      'returnType': None,
                                                                      'static': True,
                                                                      'typeQualifiers': {},
                                                                      'types': {}}],
                          'clearUVs': [{'argInfo': {'uvSet': {'doc': 'UV set to work with',
                                                              'type': 'MString'}},
                                        'args': [('uvSet',
                                                  'MString',
                                                  'in')],
                                        'defaults': {'uvSet': None},
                                        'deprecated': False,
                                        'doc': '\r\nThis method clears out all texture coordinates for the mesh, and leaves behind an empty UVset.',
                                        'inArgs': ['uvSet'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'uvSet': ['const',
                                                                     '*']},
                                        'types': {'uvSet': 'MString'}}],
                          'closestIntersection': [{'argInfo': {'accelParams': {'doc': 'optional acceleration parameters. ',
                                                                               'type': 'MMeshIsectAccelParams'},
                                                               'faceIds': {'doc': '(see above) if non-nullptr, describes a subset of faces to consider for intersection. ',
                                                                           'type': 'MIntArray'},
                                                               'hitBary1': {'doc': 'if non-nullptr, points to a value that will be filled in with the first barycentric coordinate of the hit point within the triangle defined by hitFace and *hitTriangle. If v1, v2, and v3 are the vertices of that triangle, then the barycentric coordinates are such that hitPoint = (*hitBary1)*v1 + (*hitBary2)*v2 + (1-*hitBary1-*hitBary2)*v3; If no hit was found, the referenced value will not be modified, ',
                                                                            'type': 'float'},
                                                               'hitBary2': {'doc': 'if non-nullptr, points to a value that will be filled in with the second barycentric coordinate of the hit point within the triangle defined by hitFace and *hitTriangle. If no hit was found, the referenced value will not be modified, ',
                                                                            'type': 'float'},
                                                               'hitFace': {'doc': 'if non-nullptr, points to a value that will be filled in with the face id of the hit point, if one was found. If no hit was found, the referenced value will not be modified. ',
                                                                           'type': 'int'},
                                                               'hitPoint': {'doc': 'receives the 3d coordinates of the closest intersection, in the space specified by the space parameter. ',
                                                                            'type': 'MFloatPoint'},
                                                               'hitRayParam': {'doc': 'if non-nullptr, points to a value that will be filled in with the parametric distance along the ray to the hit point, if one was found. That is, hitPoint = raySource+(*hitRayParam)*rayDirection. If no hit was found, the referenced value will not be modified. ',
                                                                               'type': 'float'},
                                                               'hitTriangle': {'doc': 'if non-nullptr, points to a value that will be filled in with the 0-based index of the triangle that was hit within the face given by *hitFace. If no hit was found, the referenced value will not be modified, ',
                                                                               'type': 'int'},
                                                               'idsSorted': {'doc': 'should be true if the faceIds or faceIds/triIds arrays are properly sorted into ascending order. For face-triangle pairs, the arrays must be sorted by ascending face ids, then by ascending triangle ids within each face. The routine sortIntersectionFaceTriIds() can be used to perform this task. It is not important to sort ids unless an acceleration structure is being used. When using an acceleration structure in conjunction with a limited set of faces or face-triangles, it is ESSENTIAL to sort the indices, otherwise performance will be severely degraded. ',
                                                                             'type': 'bool'},
                                                               'maxParam': {'doc': 'specifies the maximum radius within which hits will be considered. This radius is specified as a multiple of the length of the rayDirection vector, so any hits beyond raySource+maxParam*rayDirection will not be considered. This value must be positive. ',
                                                                            'type': 'float'},
                                                               'rayDirection': {'doc': 'Direction of the ray ',
                                                                                'type': 'MFloatVector'},
                                                               'raySource': {'doc': 'Starting point for the ray ',
                                                                             'type': 'MFloatPoint'},
                                                               'space': {'doc': 'specifies the space in which raySource and rayDirection are specified, as well as the space in which the hit point will be returned. ',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'testBothDirections': {'doc': 'specifies that hits in the negative rayDirection should also be considered. The maxParam value still applies to limit the search radius, which means that if testBothDirections is true, then only hits that lie between raySource-maxParam*rayDirection and raySource+maxParam*rayDirection will be considered. ',
                                                                                      'type': 'bool'},
                                                               'tolerance': {'doc': 'numerical tolerance for the intersection operation. For numerical reasons, it is wise to allow the intersection routine to consider hits that lie a tiny bit outside mesh triangles. This parameter defines how close a ray has to be to hitting a triangle in order for a hit to register. Obviously, hits within the triangle are always considered, but we also consider hits that are up to a distance of tol*edgeLength away from the triangle, where "edgeLength" is the length of the edge of the triangle that is closest to the ray. This tolerance value is also used to collapse multiple nearly-identical hits that may arise due to numerical imprecision when a ray passes extremely close to a mesh vertex. Any two hits that are less than tol multiplied by the length of rayDirection apart will be considered the same hit, and treated interchangeably. ',
                                                                             'type': 'float'},
                                                               'triIds': {'doc': '(see above) if non-nullptr, then along with faceIds describes a set of face-triangles to consider for intersection. If triIds is non-nullptr, then faceIds must be non-nullptr as well, otherwise an error will be generated. ',
                                                                          'type': 'MIntArray'}},
                                                   'args': [('raySource',
                                                             'MFloatPoint',
                                                             'in'),
                                                            ('rayDirection',
                                                             'MFloatVector',
                                                             'in'),
                                                            ('faceIds',
                                                             'MIntArray',
                                                             'in'),
                                                            ('triIds',
                                                             'MIntArray',
                                                             'in'),
                                                            ('idsSorted',
                                                             'bool',
                                                             'in'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in'),
                                                            ('maxParam',
                                                             'float',
                                                             'in'),
                                                            ('testBothDirections',
                                                             'bool',
                                                             'in'),
                                                            ('accelParams',
                                                             'MMeshIsectAccelParams',
                                                             'in'),
                                                            ('hitPoint',
                                                             'MFloatPoint',
                                                             'out'),
                                                            ('hitRayParam',
                                                             'float',
                                                             'out'),
                                                            ('hitFace',
                                                             'int',
                                                             'out'),
                                                            ('hitTriangle',
                                                             'int',
                                                             'out'),
                                                            ('hitBary1',
                                                             'float',
                                                             'out'),
                                                            ('hitBary2',
                                                             'float',
                                                             'out'),
                                                            ('tolerance',
                                                             'float',
                                                             'in')],
                                                   'defaults': {'tolerance': 1e-06},
                                                   'deprecated': False,
                                                   'doc': '\r\nFinds the closest intersection of a ray starting at raySource and travelling in rayDirection with the mesh. If faceIds is non-nullptr and triIds is nullptr, then only the faces specified by faceIds will be considered for intersection. If both faceIds and triIds are non-nullptr, then each pair of entries will be taken as a (face,triangle) pair to be considered for intersection, where triangles are numbered on each face starting from 0. Thus, the face-triangle pair (10,0) means the first triangle on face 10. If both faceIds and triIds are nullptr, then all face-triangles in the mesh will be considered.',
                                                   'inArgs': ['raySource',
                                                              'rayDirection',
                                                              'faceIds',
                                                              'triIds',
                                                              'idsSorted',
                                                              'space',
                                                              'maxParam',
                                                              'testBothDirections',
                                                              'accelParams',
                                                              'tolerance'],
                                                   'outArgs': ['hitPoint',
                                                               'hitRayParam',
                                                               'hitFace',
                                                               'hitTriangle',
                                                               'hitBary1',
                                                               'hitBary2'],
                                                   'returnInfo': {'doc': ' true The given ray intersects the mesh, and the closest intersection of the ray with the mesh is given by the value returned in hitPoint.  false The given ray does not intersect this mesh  ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'accelParams': ['*'],
                                                                      'faceIds': ['const',
                                                                                  '*'],
                                                                      'hitBary1': ['*'],
                                                                      'hitBary2': ['*'],
                                                                      'hitFace': ['*'],
                                                                      'hitPoint': ['&'],
                                                                      'hitRayParam': ['*'],
                                                                      'hitTriangle': ['*'],
                                                                      'idsSorted': [],
                                                                      'maxParam': [],
                                                                      'rayDirection': ['const',
                                                                                       '&'],
                                                                      'raySource': ['const',
                                                                                    '&'],
                                                                      'space': [],
                                                                      'testBothDirections': [],
                                                                      'tolerance': [],
                                                                      'triIds': ['const',
                                                                                 '*']},
                                                   'types': {'accelParams': 'MMeshIsectAccelParams',
                                                             'faceIds': 'MIntArray',
                                                             'hitBary1': 'float',
                                                             'hitBary2': 'float',
                                                             'hitFace': 'int',
                                                             'hitPoint': 'MFloatPoint',
                                                             'hitRayParam': 'float',
                                                             'hitTriangle': 'int',
                                                             'idsSorted': 'bool',
                                                             'maxParam': 'float',
                                                             'rayDirection': 'MFloatVector',
                                                             'raySource': 'MFloatPoint',
                                                             'space': ('MSpace',
                                                                       'Space'),
                                                             'testBothDirections': 'bool',
                                                             'tolerance': 'float',
                                                             'triIds': 'MIntArray'}}],
                          'collapseEdges': [{'argInfo': {'edgeList': {'doc': 'array of edge component IDs to be collapsed',
                                                                      'type': 'MIntArray'}},
                                             'args': [('edgeList',
                                                       'MIntArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis function collapse edges into vertices. The two vertices that create each given edge are replaced in turn by one vertex placed at the average of the two initial vertex.',
                                             'inArgs': ['edgeList'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'edgeList': ['&']},
                                             'types': {'edgeList': 'MIntArray'}}],
                          'collapseFaces': [{'argInfo': {'faceList': {'doc': 'array of face component IDs to be collapsed',
                                                                      'type': 'MIntArray'}},
                                             'args': [('faceList',
                                                       'MIntArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis function collapse faces into vertices. Non-adjacent faces will be collapsed individually so that each pieces of adjacent faces turn into one vertex.',
                                             'inArgs': ['faceList'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'faceList': ['&']},
                                             'types': {'faceList': 'MIntArray'}}],
                          'componentTypeFromName': [{'argInfo': {'assocName': {'doc': 'String representing the component type',
                                                                               'type': 'MString'}},
                                                     'args': [('assocName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet a component type from its string name.',
                                                     'inArgs': ['assocName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': " MFn::kInvalid The method failed to match the type.  MFn::kMeshEdgeComponent The component type is 'edge'.  MFn::kMeshPolygonComponent The component type is 'face'.  MFn::kMeshVertComponent The component type is 'vertex'.  MFn::kMeshFaceVertComponent The component type is 'faceVertex'.   ",
                                                                    'qualifiers': [],
                                                                    'type': ('MFn',
                                                                             'Type')},
                                                     'returnType': ('MFn',
                                                                    'Type'),
                                                     'static': True,
                                                     'typeQualifiers': {'assocName': ['const',
                                                                                      '&']},
                                                     'types': {'assocName': 'MString'}}],
                          'componentTypeName': [{'argInfo': {'compType': {'doc': 'The type of component to fetch ',
                                                                          'type': ('MFn',
                                                                                   'Type')}},
                                                 'args': [('compType',
                                                           ('MFn',
                                                            'Type'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet a string representing a particular component type',
                                                 'inArgs': ['compType'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'String representing the component type, empty string if invalid',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': True,
                                                 'typeQualifiers': {'compType': [],
                                                                    'status': ['&']},
                                                 'types': {'compType': ('MFn',
                                                                        'Type')}}],
                          'copy': [{'argInfo': {'parentOrOwner': {'doc': 'the DAG parent or kMeshData the new mesh will belong to ',
                                                                  'type': 'MObject'},
                                                'source': {'doc': 'the mesh to be copied ',
                                                           'type': 'MObject'}},
                                    'args': [('source', 'MObject', 'in'),
                                             ('parentOrOwner',
                                              'MObject',
                                              'in')],
                                    'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                    'deprecated': False,
                                    'doc': '\r\nThis method creates a copy of a given source mesh. After the copy this function set will operate on the new mesh.',
                                    'inArgs': ['source', 'parentOrOwner'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                   'qualifiers': [],
                                                   'type': 'MObject'},
                                    'returnType': 'MObject',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                       'parentOrOwner': [],
                                                       'source': ['const',
                                                                  '&']},
                                    'types': {'parentOrOwner': 'MObject',
                                              'source': 'MObject'}}],
                          'copyInPlace': [{'argInfo': {'source': {'doc': 'the mesh to be copied',
                                                                  'type': 'MObject'}},
                                           'args': [('source',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThis method creates copies the given source mesh onto the current surface. After the copy this function set continues operate on the original mesh.',
                                           'inArgs': ['source'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'source': ['const',
                                                                         '&']},
                                           'types': {'source': 'MObject'}}],
                          'copyUVSetWithName': [{'argInfo': {'fromName': {'doc': 'The name of the uv set to change ',
                                                                          'type': 'MString'},
                                                             'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                          'type': 'MDGModifier'},
                                                             'toName': {'doc': 'The name to set the uv set to. ',
                                                                        'type': 'MString'}},
                                                 'args': [('fromName',
                                                           'MString',
                                                           'in'),
                                                          ('toName',
                                                           'MString',
                                                           'in'),
                                                          ('modifier',
                                                           'MDGModifier',
                                                           'in')],
                                                 'defaults': {'modifier': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nCopies a uv set from one to another for this mesh. The source must exist. The following cases can occur:',
                                                 'inArgs': ['fromName',
                                                            'toName',
                                                            'modifier'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The name of the new UV set. May be different then the name passed in if a new name was generated.',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'fromName': ['const',
                                                                                 '&'],
                                                                    'modifier': ['*'],
                                                                    'toName': ['const',
                                                                               '&']},
                                                 'types': {'fromName': 'MString',
                                                           'modifier': 'MDGModifier',
                                                           'toName': 'MString'}}],
                          'create': [{'argInfo': {'numPolygons': {'doc': 'number of polygons ',
                                                                  'type': 'int'},
                                                  'numVertices': {'doc': 'number of vertices ',
                                                                  'type': 'int'},
                                                  'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                    'type': 'MObject'},
                                                  'polygonConnects': {'doc': 'array of vertex connections for each polygon. For example, in the cube, we have 4 vertices for every face, so we list the vertices for face0, face1, etc consecutively in the array. These are specified by indexes in the vertexArray: e.g for the cube: { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4, 0, 4, 7, 1, 1, 7, 6, 2 } ',
                                                                      'type': 'MIntArray'},
                                                  'polygonCounts': {'doc': 'array of vertex counts for each polygon. For example the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be {4,4,4,4,4,4}. ',
                                                                    'type': 'MIntArray'},
                                                  'vertexArray': {'doc': 'point (vertex) array. This should include all the vertices in the mesh, and no extras. For example, a cube could have the vertices: { (-1,-1,-1), (1,-1,-1), (1,-1,1), (-1,-1,1), (-1,1,-1), (-1,1,1), (1,1,1), (1,1,-1) } ',
                                                                  'type': 'MFloatPointArray'}},
                                      'args': [('numVertices',
                                                'int',
                                                'in'),
                                               ('numPolygons',
                                                'int',
                                                'in'),
                                               ('vertexArray',
                                                'MFloatPointArray',
                                                'in'),
                                               ('polygonCounts',
                                                'MIntArray',
                                                'in'),
                                               ('polygonConnects',
                                                'MIntArray',
                                                'in'),
                                               ('parentOrOwner',
                                                'MObject',
                                                'in')],
                                      'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                      'deprecated': False,
                                      'doc': '\r\nCreates a new polygonal mesh given an array of vertices and polygon connection information and sets this function set to operate on the new surface.',
                                      'inArgs': ['numVertices',
                                                 'numPolygons',
                                                 'vertexArray',
                                                 'polygonCounts',
                                                 'polygonConnects',
                                                 'parentOrOwner'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'numPolygons': [],
                                                         'numVertices': [],
                                                         'parentOrOwner': [],
                                                         'polygonConnects': ['const',
                                                                             '&'],
                                                         'polygonCounts': ['const',
                                                                           '&'],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'numPolygons': 'int',
                                                'numVertices': 'int',
                                                'parentOrOwner': 'MObject',
                                                'polygonConnects': 'MIntArray',
                                                'polygonCounts': 'MIntArray',
                                                'vertexArray': 'MFloatPointArray'}},
                                     {'argInfo': {'numPolygons': {'doc': 'number of polygons ',
                                                                  'type': 'int'},
                                                  'numVertices': {'doc': 'number of vertices ',
                                                                  'type': 'int'},
                                                  'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                    'type': 'MObject'},
                                                  'polygonConnects': {'doc': 'array of vertex connections for each polygon. For example, in the cube, we have 4 vertices for every face, so we list the vertices for face0, face1, etc consecutively in the array. These are specified by indexes in the vertexArray: e.g for the cube: { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4,0, 4, 7, 1, 1, 7, 6, 2 } ',
                                                                      'type': 'MIntArray'},
                                                  'polygonCounts': {'doc': 'array of vertex counts for each polygon. For example the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be {4,4,4,4,4,4}. ',
                                                                    'type': 'MIntArray'},
                                                  'vertexArray': {'doc': 'point (vertex) array. This should include all the vertices in the mesh, and no extras. For example, a cube could have the vertices: { (-1,-1,-1), (1,-1,-1), (1,-1,1), (-1,-1,1), (-1,1,-1), (-1,1,1), (1,1,1), (1,1,-1) } ',
                                                                  'type': 'MPointArray'}},
                                      'args': [('numVertices',
                                                'int',
                                                'in'),
                                               ('numPolygons',
                                                'int',
                                                'in'),
                                               ('vertexArray',
                                                'MPointArray',
                                                'in'),
                                               ('polygonCounts',
                                                'MIntArray',
                                                'in'),
                                               ('polygonConnects',
                                                'MIntArray',
                                                'in'),
                                               ('parentOrOwner',
                                                'MObject',
                                                'in')],
                                      'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                      'deprecated': False,
                                      'doc': '\r\nCreates a new polygonal mesh given an array of vertices and polygon connection information and sets this function set to operate on the new surface.',
                                      'inArgs': ['numVertices',
                                                 'numPolygons',
                                                 'vertexArray',
                                                 'polygonCounts',
                                                 'polygonConnects',
                                                 'parentOrOwner'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'numPolygons': [],
                                                         'numVertices': [],
                                                         'parentOrOwner': [],
                                                         'polygonConnects': ['const',
                                                                             '&'],
                                                         'polygonCounts': ['const',
                                                                           '&'],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'numPolygons': 'int',
                                                'numVertices': 'int',
                                                'parentOrOwner': 'MObject',
                                                'polygonConnects': 'MIntArray',
                                                'polygonCounts': 'MIntArray',
                                                'vertexArray': 'MPointArray'}},
                                     {'argInfo': {'numPolygons': {'doc': 'number of polygons ',
                                                                  'type': 'int'},
                                                  'numVertices': {'doc': 'number of vertices ',
                                                                  'type': 'int'},
                                                  'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                    'type': 'MObject'},
                                                  'polygonConnects': {'doc': 'array of vertex connections for each polygon. For example, in the cube, we have 4 vertices for every face, so we list the vertices for face0, face1, etc consecutively in the array. These are specified by indexes in the vertexArray: e.g for the cube: { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4,0, 4, 7, 1, 1, 7, 6, 2 } ',
                                                                      'type': 'MIntArray'},
                                                  'polygonCounts': {'doc': 'array of vertex counts for each polygon. For example the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be {4,4,4,4,4,4}. ',
                                                                    'type': 'MIntArray'},
                                                  'storeDoubles': {'doc': 'Whether to store the vertex data at double precision internally. ',
                                                                   'type': 'bool'},
                                                  'vertexArray': {'doc': 'point (vertex) array. This should include all the vertices in the mesh, and no extras. For example, a cube could have the vertices: { (-1,-1,-1), (1,-1,-1), (1,-1,1), (-1,-1,1), (-1,1,-1), (-1,1,1), (1,1,1), (1,1,-1) } ',
                                                                  'type': 'MPointArray'}},
                                      'args': [('numVertices',
                                                'int',
                                                'in'),
                                               ('numPolygons',
                                                'int',
                                                'in'),
                                               ('vertexArray',
                                                'MPointArray',
                                                'in'),
                                               ('polygonCounts',
                                                'MIntArray',
                                                'in'),
                                               ('polygonConnects',
                                                'MIntArray',
                                                'in'),
                                               ('storeDoubles',
                                                'bool',
                                                'in'),
                                               ('parentOrOwner',
                                                'MObject',
                                                'in')],
                                      'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                      'deprecated': False,
                                      'doc': '\r\nCreates a new polygonal mesh given an array of vertices and polygon connection information and sets this function set to operate on the new surface.',
                                      'inArgs': ['numVertices',
                                                 'numPolygons',
                                                 'vertexArray',
                                                 'polygonCounts',
                                                 'polygonConnects',
                                                 'storeDoubles',
                                                 'parentOrOwner'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'numPolygons': [],
                                                         'numVertices': [],
                                                         'parentOrOwner': [],
                                                         'polygonConnects': ['const',
                                                                             '&'],
                                                         'polygonCounts': ['const',
                                                                           '&'],
                                                         'storeDoubles': [],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'numPolygons': 'int',
                                                'numVertices': 'int',
                                                'parentOrOwner': 'MObject',
                                                'polygonConnects': 'MIntArray',
                                                'polygonCounts': 'MIntArray',
                                                'storeDoubles': 'bool',
                                                'vertexArray': 'MPointArray'}},
                                     {'argInfo': {'numPolygons': {'doc': 'number of polygons ',
                                                                  'type': 'int'},
                                                  'numVertices': {'doc': 'number of vertices ',
                                                                  'type': 'int'},
                                                  'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                    'type': 'MObject'},
                                                  'polygonConnects': {'doc': 'array of vertex connections for each polygon. For example, in the cube, we have 4 vertices for every face, so we list the vertices for face0, face1, etc consecutively in the array. These are specified by indexes in the vertexArray: e.g for the cube: { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4,0, 4, 7, 1, 1, 7, 6, 2 } ',
                                                                      'type': 'MIntArray'},
                                                  'polygonCounts': {'doc': 'array of vertex counts for each polygon. For example the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be {4,4,4,4,4,4}. ',
                                                                    'type': 'MIntArray'},
                                                  'uArray': {'doc': 'The array of u values to be set ',
                                                             'type': 'MFloatArray'},
                                                  'vArray': {'doc': 'The array of v values to be set ',
                                                             'type': 'MFloatArray'},
                                                  'vertexArray': {'doc': 'point (vertex) array. This should include all the vertices in the mesh, and no extras. For example, a cube could have the vertices: { (-1,-1,-1), (1,-1,-1), (1,-1,1), (-1,-1,1), (-1,1,-1), (-1,1,1), (1,1,1), (1,1,-1) } ',
                                                                  'type': 'MFloatPointArray'}},
                                      'args': [('numVertices',
                                                'int',
                                                'in'),
                                               ('numPolygons',
                                                'int',
                                                'in'),
                                               ('vertexArray',
                                                'MFloatPointArray',
                                                'in'),
                                               ('polygonCounts',
                                                'MIntArray',
                                                'in'),
                                               ('polygonConnects',
                                                'MIntArray',
                                                'in'),
                                               ('uArray',
                                                'MFloatArray',
                                                'in'),
                                               ('vArray',
                                                'MFloatArray',
                                                'in'),
                                               ('parentOrOwner',
                                                'MObject',
                                                'in')],
                                      'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                      'deprecated': False,
                                      'doc': '\r\nCreates a new polygonal mesh given an array of vertices, polygon connection information, UV information, and sets this function set to operate on the new surface.',
                                      'inArgs': ['numVertices',
                                                 'numPolygons',
                                                 'vertexArray',
                                                 'polygonCounts',
                                                 'polygonConnects',
                                                 'uArray',
                                                 'vArray',
                                                 'parentOrOwner'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'numPolygons': [],
                                                         'numVertices': [],
                                                         'parentOrOwner': [],
                                                         'polygonConnects': ['const',
                                                                             '&'],
                                                         'polygonCounts': ['const',
                                                                           '&'],
                                                         'uArray': ['const',
                                                                    '&'],
                                                         'vArray': ['const',
                                                                    '&'],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'numPolygons': 'int',
                                                'numVertices': 'int',
                                                'parentOrOwner': 'MObject',
                                                'polygonConnects': 'MIntArray',
                                                'polygonCounts': 'MIntArray',
                                                'uArray': 'MFloatArray',
                                                'vArray': 'MFloatArray',
                                                'vertexArray': 'MFloatPointArray'}},
                                     {'argInfo': {'numPolygons': {'doc': 'number of polygons ',
                                                                  'type': 'int'},
                                                  'numVertices': {'doc': 'number of vertices ',
                                                                  'type': 'int'},
                                                  'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                    'type': 'MObject'},
                                                  'polygonConnects': {'doc': 'array of vertex connections for each polygon. For example, in the cube, we have 4 vertices for every face, so we list the vertices for face0, face1, etc consecutively in the array. These are specified by indexes in the vertexArray: e.g for the cube: { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4,0, 4, 7, 1, 1, 7, 6, 2 } ',
                                                                      'type': 'MIntArray'},
                                                  'polygonCounts': {'doc': 'array of vertex counts for each polygon. For example the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be {4,4,4,4,4,4}. ',
                                                                    'type': 'MIntArray'},
                                                  'uArray': {'doc': 'The array of u values to be set ',
                                                             'type': 'MFloatArray'},
                                                  'vArray': {'doc': 'The array of v values to be set ',
                                                             'type': 'MFloatArray'},
                                                  'vertexArray': {'doc': 'point (vertex) array. This should include all the vertices in the mesh, and no extras. For example, a cube could have the vertices: { (-1,-1,-1), (1,-1,-1), (1,-1,1), (-1,-1,1), (-1,1,-1), (-1,1,1), (1,1,1), (1,1,-1) } ',
                                                                  'type': 'MPointArray'}},
                                      'args': [('numVertices',
                                                'int',
                                                'in'),
                                               ('numPolygons',
                                                'int',
                                                'in'),
                                               ('vertexArray',
                                                'MPointArray',
                                                'in'),
                                               ('polygonCounts',
                                                'MIntArray',
                                                'in'),
                                               ('polygonConnects',
                                                'MIntArray',
                                                'in'),
                                               ('uArray',
                                                'MFloatArray',
                                                'in'),
                                               ('vArray',
                                                'MFloatArray',
                                                'in'),
                                               ('parentOrOwner',
                                                'MObject',
                                                'in')],
                                      'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                      'deprecated': False,
                                      'doc': '\r\nCreates a new polygonal mesh given an array of vertices, polygon connection information, UV information, and sets this function set to operate on the new surface.',
                                      'inArgs': ['numVertices',
                                                 'numPolygons',
                                                 'vertexArray',
                                                 'polygonCounts',
                                                 'polygonConnects',
                                                 'uArray',
                                                 'vArray',
                                                 'parentOrOwner'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'numPolygons': [],
                                                         'numVertices': [],
                                                         'parentOrOwner': [],
                                                         'polygonConnects': ['const',
                                                                             '&'],
                                                         'polygonCounts': ['const',
                                                                           '&'],
                                                         'uArray': ['const',
                                                                    '&'],
                                                         'vArray': ['const',
                                                                    '&'],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'numPolygons': 'int',
                                                'numVertices': 'int',
                                                'parentOrOwner': 'MObject',
                                                'polygonConnects': 'MIntArray',
                                                'polygonCounts': 'MIntArray',
                                                'uArray': 'MFloatArray',
                                                'vArray': 'MFloatArray',
                                                'vertexArray': 'MPointArray'}},
                                     {'argInfo': {'edgeConnectsCount': {'doc': 'array of edge counts for each polygon. For example the cube would have 6 faces, each of which had 4 edges, so the edgeConnectsCount would be {4,4,4,4,4,4}. ',
                                                                        'type': 'MIntArray'},
                                                  'edgeFaceConnects': {'doc': 'array of edge connections for each polygon. For example, in the cube, we have 4 edges for every face, so we list the edges for face0, face1, etc consecutively in the array. These are specified by indexes in the edges array: e.g for the cube: { 0, 1, 2, 3, 1, 10, 5, 9, 2, 11, 6, 10, 3, 8, 7, 11, 0, 9, 4, 8, 4, 5, 6, 7 } ',
                                                                       'type': 'MIntArray'},
                                                  'edgeFaceDesc': {'doc': 'array of edge direction populated by members of MFnMesh::MEdgeDirection defining if a given edge for a polygon is intended to be in its normal direction, or in the reverse direction. Example, for the cube: { 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0} ',
                                                                   'type': 'MIntArray'},
                                                  'edges': {'doc': 'array of vertex indices that define the edges of the geometry. For example, the cube { (0,1), (1,2), (2,3), (3,0), (4,7), (7,6), (6,5), (5,4), (0,4), (1,7), (2,6), (3,5) } ',
                                                            'type': 'MIntArray'},
                                                  'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                    'type': 'MObject'},
                                                  'vertexArray': {'doc': 'point (vertex) array. This should include all the vertices in the mesh, and no extras. For example, a cube could have the vertices: { (-1,-1,-1), (1,-1,-1), (1,-1,1), (-1,-1,1), (-1,1,-1), (-1,1,1), (1,1,1), (1,1,-1) } ',
                                                                  'type': 'MFloatPointArray'}},
                                      'args': [('vertexArray',
                                                'MFloatPointArray',
                                                'in'),
                                               ('edges',
                                                'MIntArray',
                                                'in'),
                                               ('edgeConnectsCount',
                                                'MIntArray',
                                                'in'),
                                               ('edgeFaceConnects',
                                                'MIntArray',
                                                'in'),
                                               ('edgeFaceDesc',
                                                'MIntArray',
                                                'in'),
                                               ('parentOrOwner',
                                                'MObject',
                                                'in')],
                                      'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                      'deprecated': False,
                                      'doc': '\r\nCreates a new polygonal mesh given an array of vertices, edge information, polygon connection information, UV and sets this function set to operate on the new surface.',
                                      'inArgs': ['vertexArray',
                                                 'edges',
                                                 'edgeConnectsCount',
                                                 'edgeFaceConnects',
                                                 'edgeFaceDesc',
                                                 'parentOrOwner'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                     'qualifiers': [],
                                                     'type': 'MObject'},
                                      'returnType': 'MObject',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'edgeConnectsCount': ['const',
                                                                               '&'],
                                                         'edgeFaceConnects': ['const',
                                                                              '&'],
                                                         'edgeFaceDesc': ['const',
                                                                          '&'],
                                                         'edges': ['const',
                                                                   '&'],
                                                         'parentOrOwner': [],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'edgeConnectsCount': 'MIntArray',
                                                'edgeFaceConnects': 'MIntArray',
                                                'edgeFaceDesc': 'MIntArray',
                                                'edges': 'MIntArray',
                                                'parentOrOwner': 'MObject',
                                                'vertexArray': 'MFloatPointArray'}}],
                          'createBlindDataType': [{'argInfo': {'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                               'type': 'int'},
                                                               'formatNames': {'doc': 'Names of the data types.',
                                                                               'type': 'MStringArray'},
                                                               'longNames': {'doc': 'Attribute long names ',
                                                                             'type': 'MStringArray'},
                                                               'shortNames': {'doc': 'Attribute short names ',
                                                                              'type': 'MStringArray'}},
                                                   'args': [('blindDataId',
                                                             'int',
                                                             'in'),
                                                            ('longNames',
                                                             'MStringArray',
                                                             'in'),
                                                            ('shortNames',
                                                             'MStringArray',
                                                             'in'),
                                                            ('formatNames',
                                                             'MStringArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nCreate a new blind data type. If the type id is already in use, this method will fail. Format names must be one of "int" "float" "double" "boolean" "string" "binary".',
                                                   'inArgs': ['blindDataId',
                                                              'longNames',
                                                              'shortNames',
                                                              'formatNames'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'blindDataId': [],
                                                                      'formatNames': [],
                                                                      'longNames': [],
                                                                      'shortNames': []},
                                                   'types': {'blindDataId': 'int',
                                                             'formatNames': 'MStringArray',
                                                             'longNames': 'MStringArray',
                                                             'shortNames': 'MStringArray'}}],
                          'createColorSetWithName': [{'argInfo': {'colorSetName': {'doc': 'The name of the color set to add. ',
                                                                                   'type': 'MString'},
                                                                  'instances': {'doc': 'The instance number(s) for which the set should be added, or nullptr if the uv-set should be shared by all instances. ',
                                                                                'type': 'MUintArray'},
                                                                  'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                               'type': 'MDGModifier'}},
                                                      'args': [('colorSetName',
                                                                'MString',
                                                                'in'),
                                                               ('modifier',
                                                                'MDGModifier',
                                                                'in'),
                                                               ('instances',
                                                                'MUintArray',
                                                                'in')],
                                                      'defaults': {'instances': None,
                                                                   'modifier': None},
                                                      'deprecated': False,
                                                      'doc': "\r\nCreate a new empty color set for this mesh. If the name passed in is empty (zero length), or a color set with the same name already exists, then a new unique name is generated and used as the new color set's name.",
                                                      'inArgs': ['colorSetName',
                                                                 'modifier',
                                                                 'instances'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The resulting name of the color set.',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'colorSetName': ['const',
                                                                                          '&'],
                                                                         'instances': ['const',
                                                                                       '*'],
                                                                         'modifier': ['*']},
                                                      'types': {'colorSetName': 'MString',
                                                                'instances': 'MUintArray',
                                                                'modifier': 'MDGModifier'}},
                                                     {'argInfo': {'colorSetName': {'doc': 'The name of the color set to add. ',
                                                                                   'type': 'MString'},
                                                                  'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                               'type': 'MDGModifier'}},
                                                      'args': [('colorSetName',
                                                                'MString',
                                                                'in'),
                                                               ('modifier',
                                                                'MDGModifier',
                                                                'in')],
                                                      'defaults': {'modifier': None},
                                                      'deprecated': True,
                                                      'doc': '\n This method is obsolete. \n',
                                                      'inArgs': ['colorSetName',
                                                                 'modifier'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The resulting name of the color set.',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'colorSetName': ['const',
                                                                                          '&'],
                                                                         'modifier': ['*']},
                                                      'types': {'colorSetName': 'MString',
                                                                'modifier': 'MDGModifier'}}],
                          'createInPlace': [{'argInfo': {'numPolygons': {'doc': 'number of polygons ',
                                                                         'type': 'int'},
                                                         'numVertices': {'doc': 'number of vertices ',
                                                                         'type': 'int'},
                                                         'polygonConnects': {'doc': 'array of vertex connections for each polygon. For example, in the cube, we have 4 vertices for every face, so we list the vertices for face0, face1, etc consecutively in the array. These are specified by indexes in the vertexArray: e.g for the cube: { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4, 0, 4, 7, 1, 1, 7, 6, 2 }',
                                                                             'type': 'MIntArray'},
                                                         'polygonCounts': {'doc': 'array of vertex counts for each polygon. For example the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be {4,4,4,4,4,4}. ',
                                                                           'type': 'MIntArray'},
                                                         'vertexArray': {'doc': 'point (vertex) array. This should include all the vertices in the mesh, and no extras. For example, a cube could have the vertices: { (-1,-1,-1), (1,-1,-1), (1,-1,1), (-1,-1,1), (-1,1,-1), (-1,1,1), (1,1,1), (1,1,-1) } ',
                                                                         'type': 'MFloatPointArray'}},
                                             'args': [('numVertices',
                                                       'int',
                                                       'in'),
                                                      ('numPolygons',
                                                       'int',
                                                       'in'),
                                                      ('vertexArray',
                                                       'MFloatPointArray',
                                                       'in'),
                                                      ('polygonCounts',
                                                       'MIntArray',
                                                       'in'),
                                                      ('polygonConnects',
                                                       'MIntArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReplaces the existing polygonal mesh with a new one specified by array of vertices and polygon connection information. This function will then operate on the replacement surface.',
                                             'inArgs': ['numVertices',
                                                        'numPolygons',
                                                        'vertexArray',
                                                        'polygonCounts',
                                                        'polygonConnects'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'numPolygons': [],
                                                                'numVertices': [],
                                                                'polygonConnects': ['const',
                                                                                    '&'],
                                                                'polygonCounts': ['const',
                                                                                  '&'],
                                                                'vertexArray': ['const',
                                                                                '&']},
                                             'types': {'numPolygons': 'int',
                                                       'numVertices': 'int',
                                                       'polygonConnects': 'MIntArray',
                                                       'polygonCounts': 'MIntArray',
                                                       'vertexArray': 'MFloatPointArray'}}],
                          'createUVSetWithName': [{'argInfo': {'instances': {'doc': 'The instance number(s) for which the set should be added, or nullptr if the uv-set should be shared by all instances.',
                                                                             'type': 'MUintArray'},
                                                               'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                            'type': 'MDGModifier'},
                                                               'uvSetName': {'doc': 'The name of the uv set to add. If a new name needed to be generated then the new name will be returned by the function. ',
                                                                             'type': 'MString'}},
                                                   'args': [('uvSetName',
                                                             'MString',
                                                             'in'),
                                                            ('modifier',
                                                             'MDGModifier',
                                                             'in'),
                                                            ('instances',
                                                             'MUintArray',
                                                             'in')],
                                                   'defaults': {'instances': None,
                                                                'modifier': None},
                                                   'deprecated': False,
                                                   'doc': "\r\nCreate a new empty uv set for this mesh. If the name passed in is empty (zero length), or a uv set with the same name already exists, then a new unique name is generated and used as the new uvset's name.",
                                                   'inArgs': ['uvSetName',
                                                              'modifier',
                                                              'instances'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The name used for the UV set. May be different then the given name if a new name needed to be generated.',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'instances': ['const',
                                                                                    '*'],
                                                                      'modifier': ['*'],
                                                                      'uvSetName': ['const',
                                                                                    '&']},
                                                   'types': {'instances': 'MUintArray',
                                                             'modifier': 'MDGModifier',
                                                             'uvSetName': 'MString'}}],
                          'currentColorSetName': [{'argInfo': {'instance': {'doc': 'Instance of the mesh whose set we are interested in, or kMFnMeshInstanceUnspecified for the set which is shared across all instances. ',
                                                                            'type': 'int'}},
                                                   'args': [('instance',
                                                             'int',
                                                             'in')],
                                                   'defaults': {'instance': -1},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the name of the "current" or "working" color set. The "current" color set is the color set which is used for color operations when no color set is explcitly specified.',
                                                   'inArgs': ['instance'],
                                                   'inverse': ('setCurrentColorSetName',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' Name of the "current" color set, if any.  ',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'instance': []},
                                                   'types': {'instance': 'int'}}],
                          'currentUVSetName': [{'argInfo': {'instance': {'doc': 'Instance of the mesh whose set we are interested in, or kMFnMeshInstanceUnspecified for the set which is shared across all instances.',
                                                                         'type': 'int'}},
                                                'args': [('instance',
                                                          'int',
                                                          'in')],
                                                'defaults': {'instance': -1},
                                                'deprecated': False,
                                                'doc': '\r\nGet the name of the "current" uv set. The "current" uv set is the uv set which is used for uv operations when no uv set is explicitly specified.',
                                                'inArgs': ['instance'],
                                                'inverse': ('setCurrentUVSetName',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'UV set name.',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'instance': []},
                                                'types': {'instance': 'int'}}],
                          'deleteColorSet': [{'argInfo': {'colorSetName': {'doc': 'Name of the color set to delete ',
                                                                           'type': 'MString'},
                                                          'currentSelection': {'doc': 'Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.',
                                                                               'type': 'MSelectionList'},
                                                          'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                       'type': 'MDGModifier'}},
                                              'args': [('colorSetName',
                                                        'MString',
                                                        'in'),
                                                       ('modifier',
                                                        'MDGModifier',
                                                        'in'),
                                                       ('currentSelection',
                                                        'MSelectionList',
                                                        'in')],
                                              'defaults': {'currentSelection': None,
                                                           'modifier': None},
                                              'deprecated': False,
                                              'doc': '\r\nDeletes a named color set from the object. If a color set with the given name cannot be found, then no color set will be deleted.',
                                              'inArgs': ['colorSetName',
                                                         'modifier',
                                                         'currentSelection'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'colorSetName': ['const',
                                                                                  '&'],
                                                                 'currentSelection': ['*'],
                                                                 'modifier': ['*']},
                                              'types': {'colorSetName': 'MString',
                                                        'currentSelection': 'MSelectionList',
                                                        'modifier': 'MDGModifier'}}],
                          'deleteEdge': [{'argInfo': {'edgeId': {'doc': 'The edge to delete ',
                                                                 'type': 'int'},
                                                      'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                   'type': 'MDGModifier'}},
                                          'args': [('edgeId',
                                                    'int',
                                                    'in'),
                                                   ('modifier',
                                                    'MDGModifier',
                                                    'in')],
                                          'defaults': {'modifier': None},
                                          'deprecated': False,
                                          'doc': '\r\nDelete this edge.',
                                          'inArgs': ['edgeId',
                                                     'modifier'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'edgeId': [],
                                                             'modifier': ['*']},
                                          'types': {'edgeId': 'int',
                                                    'modifier': 'MDGModifier'}}],
                          'deleteFace': [{'argInfo': {'faceId': {'doc': 'The face to delete ',
                                                                 'type': 'int'},
                                                      'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                   'type': 'MDGModifier'}},
                                          'args': [('faceId',
                                                    'int',
                                                    'in'),
                                                   ('modifier',
                                                    'MDGModifier',
                                                    'in')],
                                          'defaults': {'modifier': None},
                                          'deprecated': False,
                                          'doc': '\r\nDelete this face. The method will return failure if an attempt is made to delete the last polygonal face in the object.',
                                          'inArgs': ['faceId',
                                                     'modifier'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'faceId': [],
                                                             'modifier': ['*']},
                                          'types': {'faceId': 'int',
                                                    'modifier': 'MDGModifier'}}],
                          'deleteUVSet': [{'argInfo': {'currentSelection': {'doc': 'Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.',
                                                                            'type': 'MSelectionList'},
                                                       'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                    'type': 'MDGModifier'},
                                                       'setName': {'doc': 'Name of the uv set to delete ',
                                                                   'type': 'MString'}},
                                           'args': [('setName',
                                                     'MString',
                                                     'in'),
                                                    ('modifier',
                                                     'MDGModifier',
                                                     'in'),
                                                    ('currentSelection',
                                                     'MSelectionList',
                                                     'in')],
                                           'defaults': {'currentSelection': None,
                                                        'modifier': None},
                                           'deprecated': False,
                                           'doc': '\r\nDeletes a named uv set from the object. If a uv set with the given name cannot be found, then no uv set will be deleted.',
                                           'inArgs': ['setName',
                                                      'modifier',
                                                      'currentSelection'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'currentSelection': ['*'],
                                                              'modifier': ['*'],
                                                              'setName': ['const',
                                                                          '&']},
                                           'types': {'currentSelection': 'MSelectionList',
                                                     'modifier': 'MDGModifier',
                                                     'setName': 'MString'}}],
                          'deleteVertex': [{'argInfo': {'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                     'type': 'MDGModifier'},
                                                        'vertexId': {'doc': 'The object-relative (mehs-relative/global) vertex index to delete ',
                                                                     'type': 'int'}},
                                            'args': [('vertexId',
                                                      'int',
                                                      'in'),
                                                     ('modifier',
                                                      'MDGModifier',
                                                      'in')],
                                            'defaults': {'modifier': None},
                                            'deprecated': False,
                                            'doc': '\r\nDelete this vertex.',
                                            'inArgs': ['vertexId',
                                                       'modifier'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'modifier': ['*'],
                                                               'vertexId': []},
                                            'types': {'modifier': 'MDGModifier',
                                                      'vertexId': 'int'}}],
                          'displayColors': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nDetermine if the mesh node is set to display vertex colors.',
                                             'inArgs': [],
                                             'inverse': ('setDisplayColors',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'True if the mesh node is set to display vertex colors. False otherwise.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                          'duplicateFaces': [{'argInfo': {'faceList': {'doc': 'array of face component IDs to be duplicated ',
                                                                       'type': 'MIntArray'},
                                                          'translation': {'doc': 'translation vector to apply to the duplicated elements. This is a world-space translation. Use nullptr if not required.',
                                                                          'type': 'MFloatVector'}},
                                              'args': [('faceList',
                                                        'MIntArray',
                                                        'in'),
                                                       ('translation',
                                                        'MFloatVector',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis function duplicates a set of faces and detaches them from the rest of the mesh. The resulting mesh will contain one more independant piece of geometry.',
                                              'inArgs': ['faceList',
                                                         'translation'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'faceList': ['&'],
                                                                 'translation': ['*']},
                                              'types': {'faceList': 'MIntArray',
                                                        'translation': 'MFloatVector'}}],
                          'extractFaces': [{'argInfo': {'faceList': {'doc': 'array of face component IDs to be extracted ',
                                                                     'type': 'MIntArray'},
                                                        'translation': {'doc': 'translation vector to apply to the extracted elements. This is a world-space translation. Use nullptr if not required.',
                                                                        'type': 'MFloatVector'}},
                                            'args': [('faceList',
                                                      'MIntArray',
                                                      'in'),
                                                     ('translation',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis function detaches a set of faces from the mesh so that the resulting mesh will contain one more independant piece of geometry and leaves a hole where the faces use to be.',
                                            'inArgs': ['faceList',
                                                       'translation'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'faceList': ['&'],
                                                               'translation': ['*']},
                                            'types': {'faceList': 'MIntArray',
                                                      'translation': 'MFloatVector'}}],
                          'extrudeEdges': [{'argInfo': {'edgeList': {'doc': 'array of edge component IDs to be extruded ',
                                                                     'type': 'MIntArray'},
                                                        'extrudeTogether': {'doc': 'sets whether the components should be extruded individually or together, as if one complex component was being extruded. ',
                                                                            'type': 'bool'},
                                                        'extrusionCount': {'doc': 'number of subsequent extrusions to do ',
                                                                           'type': 'int'},
                                                        'offset': {'doc': 'Edges are moved this distance in the opposite direction of the edge.',
                                                                   'type': 'float'},
                                                        'thickness': {'doc': 'Edges are moved this distance in the direction of the connected face normals. original position to give the object a consistent thickmess. ',
                                                                      'type': 'float'},
                                                        'translation': {'doc': 'translation vector to apply to the extruded elements. This is a world-space translation. Use nullptr if not required. ',
                                                                        'type': 'MFloatVector'}},
                                            'args': [('edgeList',
                                                      'MIntArray',
                                                      'in'),
                                                     ('extrusionCount',
                                                      'int',
                                                      'in'),
                                                     ('translation',
                                                      'MFloatVector',
                                                      'in'),
                                                     ('extrudeTogether',
                                                      'bool',
                                                      'in'),
                                                     ('thickness',
                                                      'float',
                                                      'in'),
                                                     ('offset',
                                                      'float',
                                                      'in')],
                                            'defaults': {'offset': '0.0f',
                                                         'thickness': '0.0f'},
                                            'deprecated': False,
                                            'doc': '\r\nThis function extrudes edges. The resulting mesh will have extra parallelograms coming out of the given edges and going to the new extruded edges. The extrusionCount argument is the number of subsequent extrusions per edges and represents the number of polygons that will be created from each given edge to the extruded edges.',
                                            'inArgs': ['edgeList',
                                                       'extrusionCount',
                                                       'translation',
                                                       'extrudeTogether',
                                                       'thickness',
                                                       'offset'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'edgeList': ['&'],
                                                               'extrudeTogether': [],
                                                               'extrusionCount': [],
                                                               'offset': [],
                                                               'thickness': [],
                                                               'translation': ['*']},
                                            'types': {'edgeList': 'MIntArray',
                                                      'extrudeTogether': 'bool',
                                                      'extrusionCount': 'int',
                                                      'offset': 'float',
                                                      'thickness': 'float',
                                                      'translation': 'MFloatVector'}}],
                          'extrudeFaces': [{'argInfo': {'extrudeTogether': {'doc': 'sets whether the components should be extruded individually or together, as if one complex component was being extruded. ',
                                                                            'type': 'bool'},
                                                        'extrusionCount': {'doc': 'number of subsequent extrusions to do ',
                                                                           'type': 'int'},
                                                        'faceList': {'doc': 'array of face component IDs to be extruded ',
                                                                     'type': 'MIntArray'},
                                                        'offset': {'doc': 'Faces are moved this distance towards the inside of the face.',
                                                                   'type': 'float'},
                                                        'thickness': {'doc': 'Faces are moved outwards this distance from their original position to give the object a consistent thickness. ',
                                                                      'type': 'float'},
                                                        'translation': {'doc': 'translation vector to apply to the extruded elements. This is a world-space translation. Use nullptr if not required. ',
                                                                        'type': 'MFloatVector'}},
                                            'args': [('faceList',
                                                      'MIntArray',
                                                      'in'),
                                                     ('extrusionCount',
                                                      'int',
                                                      'in'),
                                                     ('translation',
                                                      'MFloatVector',
                                                      'in'),
                                                     ('extrudeTogether',
                                                      'bool',
                                                      'in'),
                                                     ('thickness',
                                                      'float',
                                                      'in'),
                                                     ('offset',
                                                      'float',
                                                      'in')],
                                            'defaults': {'offset': '0.0f',
                                                         'thickness': '0.0f'},
                                            'deprecated': False,
                                            'doc': '\r\nThis function extrudes a set of faces. The resulting mesh will have extra parallelograms coming out of the edges of the given polygons going to the new extruded edges. The extrusionCount argument is the number of subsequent extrusions per polygon and represents the number of faces that will be created for each edge of the polygons in the list.',
                                            'inArgs': ['faceList',
                                                       'extrusionCount',
                                                       'translation',
                                                       'extrudeTogether',
                                                       'thickness',
                                                       'offset'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'extrudeTogether': [],
                                                               'extrusionCount': [],
                                                               'faceList': ['&'],
                                                               'offset': [],
                                                               'thickness': [],
                                                               'translation': ['*']},
                                            'types': {'extrudeTogether': 'bool',
                                                      'extrusionCount': 'int',
                                                      'faceList': 'MIntArray',
                                                      'offset': 'float',
                                                      'thickness': 'float',
                                                      'translation': 'MFloatVector'}}],
                          'freeCachedIntersectionAccelerator': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nIf the mesh has a cached accelerator structure, then this routine forces it to be deleted. Ordinarily, these structures are cached so that series of calls to the geometric query methods that make use of it can reuse the same structure. Once the client is finished with a series of method calls, however, they are responsible for freeing the acceleration structure, which is what this method does.',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                          'generateSmoothMesh': [{'argInfo': {'options': {'doc': 'Set of options to use when generating the smoothed mesh ',
                                                                          'type': 'MMeshSmoothOptions'},
                                                              'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                                'type': 'MObject'}},
                                                  'args': [('parentOrOwner',
                                                            'MObject',
                                                            'in'),
                                                           ('options',
                                                            'MMeshSmoothOptions',
                                                            'in')],
                                                  'defaults': {'options': None,
                                                               'parentOrOwner': 'MObject::kNullObj'},
                                                  'deprecated': False,
                                                  'doc': '\r\nCreates a new polygonal mesh using either the Smooth Mesh Preview attributes of this mesh or a set of options specified in an  MMeshSmoothOptions  object. Unlike the  MFnMesh::create  functions, this function does not set this function set to operate on the new surface.',
                                                  'inArgs': ['parentOrOwner',
                                                             'options'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'options': ['*'],
                                                                     'parentOrOwner': []},
                                                  'types': {'options': 'MMeshSmoothOptions',
                                                            'parentOrOwner': 'MObject'}},
                                                 {'argInfo': {'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                                'type': 'MObject'}},
                                                  'args': [('parentOrOwner',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': True,
                                                  'doc': '\n This method is obsolete. \n',
                                                  'inArgs': ['parentOrOwner'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'parentOrOwner': []},
                                                  'types': {'parentOrOwner': 'MObject'}}],
                          'getAssignedUVs': [{'argInfo': {'uvCounts': {'doc': 'The container for the uv counts for each polygon in the mesh ',
                                                                       'type': 'MIntArray'},
                                                          'uvIds': {'doc': 'The container for the uv indices mapped to each polygon-vertex ',
                                                                    'type': 'MIntArray'},
                                                          'uvSet': {'doc': 'UV set to work with',
                                                                    'type': 'MString'}},
                                              'args': [('uvCounts',
                                                        'MIntArray',
                                                        'out'),
                                                       ('uvIds',
                                                        'MIntArray',
                                                        'out'),
                                                       ('uvSet',
                                                        'MString',
                                                        'in')],
                                              'defaults': {'uvSet': None},
                                              'deprecated': False,
                                              'doc': '\r\nGet assigned UVs. This method finds all texture coordinates for the mesh that have been mapped, and returns them in the same format as the assignUVs.',
                                              'inArgs': ['uvSet'],
                                              'outArgs': ['uvCounts',
                                                          'uvIds'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'uvCounts': ['&'],
                                                                 'uvIds': ['&'],
                                                                 'uvSet': ['const',
                                                                           '*']},
                                              'types': {'uvCounts': 'MIntArray',
                                                        'uvIds': 'MIntArray',
                                                        'uvSet': 'MString'}}],
                          'getAssociatedColorSetInstances': [{'argInfo': {'colorSetName': {'doc': 'Name of color set to use ',
                                                                                           'type': 'MString'},
                                                                          'instances': {'doc': 'Instances associated with this color set',
                                                                                        'type': 'MIntArray'}},
                                                              'args': [('colorSetName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('instances',
                                                                        'MIntArray',
                                                                        'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nGet a list of the instance numbers associated with this color map. If the color map is shared across all instances, an empty array will be returned.',
                                                              'inArgs': ['colorSetName'],
                                                              'outArgs': ['instances'],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'colorSetName': ['const',
                                                                                                  '&'],
                                                                                 'instances': ['&']},
                                                              'types': {'colorSetName': 'MString',
                                                                        'instances': 'MIntArray'}}],
                          'getAssociatedUVSetInstances': [{'argInfo': {'instances': {'doc': 'Instances associated with this uv set',
                                                                                     'type': 'MIntArray'},
                                                                       'uvSetName': {'doc': 'Name of uv set to use ',
                                                                                     'type': 'MString'}},
                                                           'args': [('uvSetName',
                                                                     'MString',
                                                                     'in'),
                                                                    ('instances',
                                                                     'MIntArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nGet a list of the instance numbers associated with this uv map. If the uv map is shared across all instances, an empty array will be returned.',
                                                           'inArgs': ['uvSetName'],
                                                           'outArgs': ['instances'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'instances': ['&'],
                                                                              'uvSetName': ['const',
                                                                                            '&']},
                                                           'types': {'instances': 'MIntArray',
                                                                     'uvSetName': 'MString'}}],
                          'getAssociatedUVSetTextures': [{'argInfo': {'textures': {'doc': 'Texture nodes using the uv set',
                                                                                   'type': 'MObjectArray'},
                                                                      'uvSetName': {'doc': 'Name of uv set to use ',
                                                                                    'type': 'MString'}},
                                                          'args': [('uvSetName',
                                                                    'MString',
                                                                    'in'),
                                                                   ('textures',
                                                                    'MObjectArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGet a list of texture nodes which are using a given uv set. If the texture has a 2d texture placement, the texture, and not the placement will be returned.',
                                                          'inArgs': ['uvSetName'],
                                                          'outArgs': ['textures'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'textures': ['&'],
                                                                             'uvSetName': ['const']},
                                                          'types': {'textures': 'MObjectArray',
                                                                    'uvSetName': 'MString'}}],
                          'getAxisAtPoint': [{'argInfo': {'closestPolygon': {'doc': 'polygon id of the closest polygon',
                                                                             'type': 'int'},
                                                          'normal': {'doc': 'Space for the normal ',
                                                                     'type': 'MVector'},
                                                          'pt': {'doc': 'The point to be queried ',
                                                                 'type': 'MPoint'},
                                                          'space': {'doc': 'The coordinate system for this operation ',
                                                                    'type': ('MSpace',
                                                                             'Space')},
                                                          'uTangent': {'doc': 'Space for the U tangent ',
                                                                       'type': 'MVector'},
                                                          'uvSet': {'doc': 'UV set to work with ',
                                                                    'type': 'MString'},
                                                          'vTangent': {'doc': 'Space for the V tangent ',
                                                                       'type': 'MVector'}},
                                              'args': [('pt',
                                                        'MPoint',
                                                        'in'),
                                                       ('normal',
                                                        'MVector',
                                                        'out'),
                                                       ('uTangent',
                                                        'MVector',
                                                        'out'),
                                                       ('vTangent',
                                                        'MVector',
                                                        'out'),
                                                       ('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in'),
                                                       ('uvSet',
                                                        'MString',
                                                        'in'),
                                                       ('closestPolygon',
                                                        'int',
                                                        'out')],
                                              'defaults': {'closestPolygon': None,
                                                           'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject'),
                                                           'uvSet': None},
                                              'deprecated': False,
                                              'doc': '\r\nFind the point on the mesh which is closest to the given point, and return the axis at that point.',
                                              'inArgs': ['pt',
                                                         'space',
                                                         'uvSet'],
                                              'outArgs': ['normal',
                                                          'uTangent',
                                                          'vTangent',
                                                          'closestPolygon'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'closestPolygon': ['*'],
                                                                 'normal': ['&'],
                                                                 'pt': ['&'],
                                                                 'space': [],
                                                                 'uTangent': ['&'],
                                                                 'uvSet': ['const',
                                                                           '*'],
                                                                 'vTangent': ['&']},
                                              'types': {'closestPolygon': 'int',
                                                        'normal': 'MVector',
                                                        'pt': 'MPoint',
                                                        'space': ('MSpace',
                                                                  'Space'),
                                                        'uTangent': 'MVector',
                                                        'uvSet': 'MString',
                                                        'vTangent': 'MVector'}}],
                          'getBinaryBlindData': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The blind data id to check for ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'Space for the component indexes of the items When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': "Space for the data items (note that we return the bool data as an MIntArray since we don't have a convenient bool array type",
                                                                       'type': 'MStringArray'}},
                                                  'args': [('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('compIDs',
                                                            'MIntArray',
                                                            'out'),
                                                           ('data',
                                                            'MStringArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.',
                                                  'inArgs': ['compType',
                                                             'blindDataId',
                                                             'attrName'],
                                                  'inverse': ('setBinaryBlindData',
                                                              False),
                                                  'outArgs': ['compIDs',
                                                              'data'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': ['&']},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MStringArray'}}],
                          'getBinormals': [{'argInfo': {'binormals': {'doc': 'Storage for the binormals. ',
                                                                      'type': 'MFloatVectorArray'},
                                                        'space': {'doc': 'Specifies the coordinate system for this operation. ',
                                                                  'type': ('MSpace',
                                                                           'Space')},
                                                        'uvSet': {'doc': 'The uv map set to calculate the binormals aginst.',
                                                                  'type': 'MString'}},
                                            'args': [('binormals',
                                                      'MFloatVectorArray',
                                                      'out'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject'),
                                                         'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the binormal vectors for all face vertices.',
                                            'inArgs': ['space', 'uvSet'],
                                            'outArgs': ['binormals'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'binormals': ['&'],
                                                               'space': [],
                                                               'uvSet': ['const',
                                                                         '*']},
                                            'types': {'binormals': 'MFloatVectorArray',
                                                      'space': ('MSpace',
                                                                'Space'),
                                                      'uvSet': 'MString'}}],
                          'getBlindDataAttrNames': [{'argInfo': {'blindDataId': {'doc': 'The blind data id to check for ',
                                                                                 'type': 'int'},
                                                                 'formatNames': {'doc': 'Space for the data format names',
                                                                                 'type': 'MStringArray'},
                                                                 'longNames': {'doc': 'Space for the attribute long names ',
                                                                               'type': 'MStringArray'},
                                                                 'shortNames': {'doc': 'Space for the attribute short names ',
                                                                                'type': 'MStringArray'}},
                                                     'args': [('blindDataId',
                                                               'int',
                                                               'in'),
                                                              ('longNames',
                                                               'MStringArray',
                                                               'out'),
                                                              ('shortNames',
                                                               'MStringArray',
                                                               'out'),
                                                              ('formatNames',
                                                               'MStringArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the blind data attribute names and types for the specified blind data type id. Format names will be one of "int" "float" "double" "boolean" "string" "binary".',
                                                     'inArgs': ['blindDataId'],
                                                     'outArgs': ['longNames',
                                                                 'shortNames',
                                                                 'formatNames'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'blindDataId': [],
                                                                        'formatNames': ['&'],
                                                                        'longNames': ['&'],
                                                                        'shortNames': ['&']},
                                                     'types': {'blindDataId': 'int',
                                                               'formatNames': 'MStringArray',
                                                               'longNames': 'MStringArray',
                                                               'shortNames': 'MStringArray'}},
                                                    {'argInfo': {'blindDataId': {'doc': 'The blind data id to check for ',
                                                                                 'type': 'int'},
                                                                 'longNames': {'doc': 'Space for the attribute long names ',
                                                                               'type': 'MStringArray'},
                                                                 'shortNames': {'doc': 'Space for the attribute short names',
                                                                                'type': 'MStringArray'}},
                                                     'args': [('blindDataId',
                                                               'int',
                                                               'in'),
                                                              ('longNames',
                                                               'MStringArray',
                                                               'out'),
                                                              ('shortNames',
                                                               'MStringArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the blind data attribute names for the specified blind data type id.',
                                                     'inArgs': ['blindDataId'],
                                                     'outArgs': ['longNames',
                                                                 'shortNames'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'blindDataId': [],
                                                                        'longNames': ['&'],
                                                                        'shortNames': ['&']},
                                                     'types': {'blindDataId': 'int',
                                                               'longNames': 'MStringArray',
                                                               'shortNames': 'MStringArray'}}],
                          'getBlindDataFaceVertexIndices': [{'argInfo': {'blindDataIndex': {'doc': 'The component index for face vertex blind data storage to decompose ',
                                                                                            'type': 'int'},
                                                                         'faceIndex': {'doc': 'The corresponding face index to be returned ',
                                                                                       'type': 'int'},
                                                                         'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index to be returned',
                                                                                         'type': 'int'}},
                                                             'args': [('blindDataIndex',
                                                                       'int',
                                                                       'out'),
                                                                      ('faceIndex',
                                                                       'int',
                                                                       'out'),
                                                                      ('vertexIndex',
                                                                       'int',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nGet the face and vertex indices from the face-vertex blind data index.',
                                                             'inArgs': [],
                                                             'outArgs': ['blindDataIndex',
                                                                         'faceIndex',
                                                                         'vertexIndex'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'blindDataIndex': [],
                                                                                'faceIndex': ['&'],
                                                                                'vertexIndex': ['&']},
                                                             'types': {'blindDataIndex': 'int',
                                                                       'faceIndex': 'int',
                                                                       'vertexIndex': 'int'}}],
                          'getBlindDataTypes': [{'argInfo': {'blindDataIds': {'doc': 'space for this list of blind data id values.',
                                                                              'type': 'MIntArray'},
                                                             'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                          'type': ('MFn',
                                                                                   'Type')}},
                                                 'args': [('compType',
                                                           ('MFn',
                                                            'Type'),
                                                           'in'),
                                                          ('blindDataIds',
                                                           'MIntArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nGet the list of blind data ID's associated with the given component type on this mesh. (e.g. all blind data ID's present on vertex compontents)",
                                                 'inArgs': ['compType'],
                                                 'outArgs': ['blindDataIds'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'blindDataIds': ['&'],
                                                                    'compType': []},
                                                 'types': {'blindDataIds': 'MIntArray',
                                                           'compType': ('MFn',
                                                                        'Type')}}],
                          'getBoolBlindData': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                         'type': 'MString'},
                                                            'blindDataId': {'doc': 'The blind data id to check for ',
                                                                            'type': 'int'},
                                                            'compID': {'doc': 'The component to get for blind data on When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                       'type': 'int'},
                                                            'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                         'type': ('MFn',
                                                                                  'Type')},
                                                            'data': {'doc': 'Space for the data item',
                                                                     'type': 'bool'}},
                                                'args': [('compID',
                                                          'int',
                                                          'in'),
                                                         ('compType',
                                                          ('MFn',
                                                           'Type'),
                                                          'in'),
                                                         ('blindDataId',
                                                          'int',
                                                          'in'),
                                                         ('attrName',
                                                          'MString',
                                                          'in'),
                                                         ('data',
                                                          'bool',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.',
                                                'inArgs': ['compID',
                                                           'compType',
                                                           'blindDataId',
                                                           'attrName'],
                                                'inverse': ('setBoolBlindData',
                                                            False),
                                                'outArgs': ['data'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attrName': [],
                                                                   'blindDataId': [],
                                                                   'compID': [],
                                                                   'compType': [],
                                                                   'data': ['&']},
                                                'types': {'attrName': 'MString',
                                                          'blindDataId': 'int',
                                                          'compID': 'int',
                                                          'compType': ('MFn',
                                                                       'Type'),
                                                          'data': 'bool'}},
                                               {'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                         'type': 'MString'},
                                                            'blindDataId': {'doc': 'The blind data id to check for ',
                                                                            'type': 'int'},
                                                            'compIDs': {'doc': 'Space for the component indexes of the items When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                        'type': 'MIntArray'},
                                                            'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                         'type': ('MFn',
                                                                                  'Type')},
                                                            'data': {'doc': "Space for the data items (note that we return the bool data as an MIntArray since we don't have a convenient bool array type",
                                                                     'type': 'MIntArray'}},
                                                'args': [('compType',
                                                          ('MFn',
                                                           'Type'),
                                                          'in'),
                                                         ('blindDataId',
                                                          'int',
                                                          'in'),
                                                         ('attrName',
                                                          'MString',
                                                          'in'),
                                                         ('compIDs',
                                                          'MIntArray',
                                                          'out'),
                                                         ('data',
                                                          'MIntArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.',
                                                'inArgs': ['compType',
                                                           'blindDataId',
                                                           'attrName'],
                                                'inverse': ('setBoolBlindData',
                                                            False),
                                                'outArgs': ['compIDs',
                                                            'data'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attrName': [],
                                                                   'blindDataId': [],
                                                                   'compIDs': ['&'],
                                                                   'compType': [],
                                                                   'data': ['&']},
                                                'types': {'attrName': 'MString',
                                                          'blindDataId': 'int',
                                                          'compIDs': 'MIntArray',
                                                          'compType': ('MFn',
                                                                       'Type'),
                                                          'data': 'MIntArray'}}],
                          'getCheckSamePointTwice': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn true if checking for duplicate points is turned on. Return false otherwise. \r\n',
                                                      'inArgs': [],
                                                      'inverse': ('setCheckSamePointTwice',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                          'getClosestNormal': [{'argInfo': {'accelParams': {'doc': 'optional acceleration parameters',
                                                                            'type': 'MMeshIsectAccelParams'},
                                                            'closestPolygon': {'doc': 'Storage for the closest polygon id ',
                                                                               'type': 'int'},
                                                            'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                      'type': ('MSpace',
                                                                               'Space')},
                                                            'theNormal': {'doc': 'Storage for normal at the closest point ',
                                                                          'type': 'MVector'},
                                                            'toThisPoint': {'doc': 'Point to be compared ',
                                                                            'type': 'MPoint'}},
                                                'args': [('toThisPoint',
                                                          'MPoint',
                                                          'in'),
                                                         ('theNormal',
                                                          'MVector',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in'),
                                                         ('closestPolygon',
                                                          'int',
                                                          'out'),
                                                         ('accelParams',
                                                          'MMeshIsectAccelParams',
                                                          'in')],
                                                'defaults': {'accelParams': None,
                                                             'closestPolygon': None,
                                                             'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the closest point on this surface to the given point. This method also returns the surface normal at that point.',
                                                'inArgs': ['toThisPoint',
                                                           'space',
                                                           'accelParams'],
                                                'outArgs': ['theNormal',
                                                            'closestPolygon'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'accelParams': ['*'],
                                                                   'closestPolygon': ['*'],
                                                                   'space': [],
                                                                   'theNormal': ['&'],
                                                                   'toThisPoint': ['const',
                                                                                   '&']},
                                                'types': {'accelParams': 'MMeshIsectAccelParams',
                                                          'closestPolygon': 'int',
                                                          'space': ('MSpace',
                                                                    'Space'),
                                                          'theNormal': 'MVector',
                                                          'toThisPoint': 'MPoint'}}],
                          'getClosestPoint': [{'argInfo': {'accelParams': {'doc': 'optional acceleration parameters',
                                                                           'type': 'MMeshIsectAccelParams'},
                                                           'closestPolygon': {'doc': 'Storage for the closest polygon id ',
                                                                              'type': 'int'},
                                                           'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                     'type': ('MSpace',
                                                                              'Space')},
                                                           'theClosestPoint': {'doc': 'Storage for the closest point ',
                                                                               'type': 'MPoint'},
                                                           'toThisPoint': {'doc': 'Point to be compared ',
                                                                           'type': 'MPoint'}},
                                               'args': [('toThisPoint',
                                                         'MPoint',
                                                         'in'),
                                                        ('theClosestPoint',
                                                         'MPoint',
                                                         'out'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in'),
                                                        ('closestPolygon',
                                                         'int',
                                                         'out'),
                                                        ('accelParams',
                                                         'MMeshIsectAccelParams',
                                                         'in')],
                                               'defaults': {'accelParams': None,
                                                            'closestPolygon': None,
                                                            'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the closest point on this surface to the given point.',
                                               'inArgs': ['toThisPoint',
                                                          'space',
                                                          'accelParams'],
                                               'outArgs': ['theClosestPoint',
                                                           'closestPolygon'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'accelParams': ['*'],
                                                                  'closestPolygon': ['*'],
                                                                  'space': [],
                                                                  'theClosestPoint': ['&'],
                                                                  'toThisPoint': ['const',
                                                                                  '&']},
                                               'types': {'accelParams': 'MMeshIsectAccelParams',
                                                         'closestPolygon': 'int',
                                                         'space': ('MSpace',
                                                                   'Space'),
                                                         'theClosestPoint': 'MPoint',
                                                         'toThisPoint': 'MPoint'}}],
                          'getClosestPointAndNormal': [{'argInfo': {'accelParams': {'doc': 'optional acceleration parameters',
                                                                                    'type': 'MMeshIsectAccelParams'},
                                                                    'closestPolygon': {'doc': 'Storage for the closest polygon id ',
                                                                                       'type': 'int'},
                                                                    'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                              'type': ('MSpace',
                                                                                       'Space')},
                                                                    'theClosestPoint': {'doc': 'Storage for the closest point ',
                                                                                        'type': 'MPoint'},
                                                                    'theNormal': {'doc': 'Storage for normal at the closest point ',
                                                                                  'type': 'MVector'},
                                                                    'toThisPoint': {'doc': 'Point to be compared ',
                                                                                    'type': 'MPoint'}},
                                                        'args': [('toThisPoint',
                                                                  'MPoint',
                                                                  'in'),
                                                                 ('theClosestPoint',
                                                                  'MPoint',
                                                                  'out'),
                                                                 ('theNormal',
                                                                  'MVector',
                                                                  'out'),
                                                                 ('space',
                                                                  ('MSpace',
                                                                   'Space'),
                                                                  'in'),
                                                                 ('closestPolygon',
                                                                  'int',
                                                                  'out'),
                                                                 ('accelParams',
                                                                  'MMeshIsectAccelParams',
                                                                  'in')],
                                                        'defaults': {'accelParams': None,
                                                                     'closestPolygon': None,
                                                                     'space': ('MSpace',
                                                                               'Space',
                                                                               'kObject')},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the closest point on this surface to the given point. This method also returns the surface normal at that point.',
                                                        'inArgs': ['toThisPoint',
                                                                   'space',
                                                                   'accelParams'],
                                                        'outArgs': ['theClosestPoint',
                                                                    'theNormal',
                                                                    'closestPolygon'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'accelParams': ['*'],
                                                                           'closestPolygon': ['*'],
                                                                           'space': [],
                                                                           'theClosestPoint': ['&'],
                                                                           'theNormal': ['&'],
                                                                           'toThisPoint': ['const',
                                                                                           '&']},
                                                        'types': {'accelParams': 'MMeshIsectAccelParams',
                                                                  'closestPolygon': 'int',
                                                                  'space': ('MSpace',
                                                                            'Space'),
                                                                  'theClosestPoint': 'MPoint',
                                                                  'theNormal': 'MVector',
                                                                  'toThisPoint': 'MPoint'}}],
                          'getClosestUVs': [{'argInfo': {'toThisUVPoint': {'doc': 'UV coordinate to be compared ',
                                                                           'type': 'float2'},
                                                         'uvIds': {'doc': 'The list of the closest uvs ids ',
                                                                   'type': 'MIntArray'},
                                                         'uvSet': {'doc': 'UV set to work with',
                                                                   'type': 'MString'}},
                                             'args': [('toThisUVPoint',
                                                       'float2',
                                                       'in'),
                                                      ('uvIds',
                                                       'MIntArray',
                                                       'out'),
                                                      ('uvSet',
                                                       'MString',
                                                       'in')],
                                             'defaults': {'uvSet': None},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the IDs of the UVs on this surface which are nearest in uv space to the given uv set and coordinate. All these UVs locate at the same distance to the given coordinate.',
                                             'inArgs': ['toThisUVPoint',
                                                        'uvSet'],
                                             'outArgs': ['uvIds'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'toThisUVPoint': ['const',
                                                                                  '&'],
                                                                'uvIds': ['&'],
                                                                'uvSet': ['const',
                                                                          '*']},
                                             'types': {'toThisUVPoint': 'float2',
                                                       'uvIds': 'MIntArray',
                                                       'uvSet': 'MString'}}],
                          'getColor': [{'argInfo': {'color': {'doc': 'Storage for the color value ',
                                                              'type': 'MColor'},
                                                    'colorId': {'doc': 'The element in the color list to examine ',
                                                                'type': 'int'},
                                                    'colorSet': {'doc': 'Color set to work with ',
                                                                 'type': 'MString'},
                                                    'defaultUnsetColor': {'doc': 'default unset color',
                                                                          'type': 'MColor'}},
                                        'args': [('colorId',
                                                  'int',
                                                  'in'),
                                                 ('color',
                                                  'MColor',
                                                  'out'),
                                                 ('colorSet',
                                                  'MString',
                                                  'in'),
                                                 ('defaultUnsetColor',
                                                  'MColor',
                                                  'in')],
                                        'defaults': {'colorSet': None,
                                                     'defaultUnsetColor': None},
                                        'deprecated': False,
                                        'doc': "\r\nGet the value of the specified texture coordinate from this mesh's color list. The colorId is the element in the color list that will be retrieved. If the color is not set, defaultUnsetColor will be return. If defaultUnsetColor is not set, (0,0,0,1) will be return.",
                                        'inArgs': ['colorId',
                                                   'colorSet',
                                                   'defaultUnsetColor'],
                                        'inverse': ('setColor', False),
                                        'outArgs': ['color'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'color': ['&'],
                                                           'colorId': [],
                                                           'colorSet': ['const',
                                                                        '*'],
                                                           'defaultUnsetColor': ['const',
                                                                                 '*']},
                                        'types': {'color': 'MColor',
                                                  'colorId': 'int',
                                                  'colorSet': 'MString',
                                                  'defaultUnsetColor': 'MColor'}}],
                          'getColorIndex': [{'argInfo': {'colorIndex': {'doc': 'Storage for the color index to be returned. ',
                                                                        'type': 'int'},
                                                         'colorSet': {'doc': 'Color set to work with',
                                                                      'type': 'MString'},
                                                         'faceIndex': {'doc': 'The face to look for ',
                                                                       'type': 'int'},
                                                         'localVertexIndex': {'doc': 'The face-relative (local) vertex id to look for ',
                                                                              'type': 'int'}},
                                             'args': [('faceIndex',
                                                       'int',
                                                       'in'),
                                                      ('localVertexIndex',
                                                       'int',
                                                       'in'),
                                                      ('colorIndex',
                                                       'int',
                                                       'out'),
                                                      ('colorSet',
                                                       'MString',
                                                       'in')],
                                             'defaults': {'colorSet': None},
                                             'deprecated': False,
                                             'doc': '\r\nGet an index into the array returned by getColors.',
                                             'inArgs': ['faceIndex',
                                                        'localVertexIndex',
                                                        'colorSet'],
                                             'outArgs': ['colorIndex'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'colorIndex': ['&'],
                                                                'colorSet': ['const',
                                                                             '*'],
                                                                'faceIndex': [],
                                                                'localVertexIndex': []},
                                             'types': {'colorIndex': 'int',
                                                       'colorSet': 'MString',
                                                       'faceIndex': 'int',
                                                       'localVertexIndex': 'int'}}],
                          'getColorRepresentation': [{'argInfo': {'colorSet': {'doc': 'Color set to work with ',
                                                                               'type': 'MString'}},
                                                      'args': [('colorSet',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method returns the color representation (RGB/RGBA/A) of a color set.',
                                                      'inArgs': ['colorSet'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': ' kAlpha The color set contains only Alpha component  kRGB The color set contains only RGB components  kRGBA The color set contains RGBA components  ',
                                                                     'qualifiers': [],
                                                                     'type': ('MFnMesh',
                                                                              'MColorRepresentation')},
                                                      'returnType': ('MFnMesh',
                                                                     'MColorRepresentation'),
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'colorSet': ['const',
                                                                                      '&']},
                                                      'types': {'colorSet': 'MString'}}],
                          'getColorSetFamilyNames': [{'argInfo': {'familyNames': {'doc': 'Array of color set names found',
                                                                                  'type': 'MStringArray'}},
                                                      'args': [('familyNames',
                                                                'MStringArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the names of all of the color set families on this object. A color set family is a set of per-instance sets with the same name with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family.',
                                                      'inArgs': [],
                                                      'outArgs': ['familyNames'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'familyNames': ['&']},
                                                      'types': {'familyNames': 'MStringArray'}}],
                          'getColorSetNames': [{'argInfo': {'setNames': {'doc': 'Array of color set names found',
                                                                         'type': 'MStringArray'}},
                                                'args': [('setNames',
                                                          'MStringArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the names of all of the colors sets on this object.',
                                                'inArgs': [],
                                                'outArgs': ['setNames'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'setNames': ['&']},
                                                'types': {'setNames': 'MStringArray'}}],
                          'getColorSetsInFamily': [{'argInfo': {'familyName': {'doc': 'The color set family name ',
                                                                               'type': 'MString'},
                                                                'setNames': {'doc': 'Array of color set names in the family',
                                                                             'type': 'MStringArray'}},
                                                    'args': [('familyName',
                                                              'MString',
                                                              'out'),
                                                             ('setNames',
                                                              'MStringArray',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the names of the color sets that belong to this set family. Per-instance sets will have multiple sets in a family, with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family and will share the same name as its family.',
                                                    'inArgs': [],
                                                    'outArgs': ['familyName',
                                                                'setNames'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'familyName': ['const',
                                                                                      '&'],
                                                                       'setNames': ['&']},
                                                    'types': {'familyName': 'MString',
                                                              'setNames': 'MStringArray'}}],
                          'getColors': [{'argInfo': {'colorArray': {'doc': 'Storage for the color values list ',
                                                                    'type': 'MColorArray'},
                                                     'colorSet': {'doc': 'Color set to work with ',
                                                                  'type': 'MString'},
                                                     'defaultUnsetColor': {'doc': 'Default unset color',
                                                                           'type': 'MColor'}},
                                         'args': [('colorArray',
                                                   'MColorArray',
                                                   'out'),
                                                  ('colorSet',
                                                   'MString',
                                                   'in'),
                                                  ('defaultUnsetColor',
                                                   'MColor',
                                                   'in')],
                                         'defaults': {'colorSet': None,
                                                      'defaultUnsetColor': None},
                                         'deprecated': False,
                                         'doc': '\r\nThis method copies the color array for this mesh into the given color array. Use the index returned by getColorIndex to access the array. If the color is not set for a vertex, defaultUnsetColor will be return. If defaultUnsetColor is not set, (0,0,0,1) will be return.',
                                         'inArgs': ['colorSet',
                                                    'defaultUnsetColor'],
                                         'inverse': ('setColors', False),
                                         'outArgs': ['colorArray'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'colorArray': ['&'],
                                                            'colorSet': ['const',
                                                                         '*'],
                                                            'defaultUnsetColor': ['const',
                                                                                  '*']},
                                         'types': {'colorArray': 'MColorArray',
                                                   'colorSet': 'MString',
                                                   'defaultUnsetColor': 'MColor'}}],
                          'getConnectedShaders': [{'argInfo': {'indices': {'doc': 'Storage for indices matching faces to shaders. For each face, this array contains the index into the shaders array for the shader assigned to the face.',
                                                                           'type': 'MIntArray'},
                                                               'instanceNumber': {'doc': 'The instance number of the mesh to query ',
                                                                                  'type': 'uint'},
                                                               'shaders': {'doc': 'Storage for set objects (shader objects) ',
                                                                           'type': 'MObjectArray'}},
                                                   'args': [('instanceNumber',
                                                             'uint',
                                                             'in'),
                                                            ('shaders',
                                                             'MObjectArray',
                                                             'out'),
                                                            ('indices',
                                                             'MIntArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns all the shaders (sets) connected to the specified instance of this mesh, as well as an array of polygon/shader assignments. The indices array will hold, for each polygon in the mesh, an index into the shaders array. If a polygon does not have a shader assigned to it, the value of the index will be -1.',
                                                   'inArgs': ['instanceNumber'],
                                                   'outArgs': ['shaders',
                                                               'indices'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'indices': ['&'],
                                                                      'instanceNumber': ['unsigned'],
                                                                      'shaders': ['&']},
                                                   'types': {'indices': 'MIntArray',
                                                             'instanceNumber': 'uint',
                                                             'shaders': 'MObjectArray'}}],
                          'getCreaseEdges': [{'argInfo': {'creaseData': {'doc': 'The data related to the crease edges.',
                                                                         'type': 'MDoubleArray'},
                                                          'edgeIds': {'doc': 'The list of crease edges ids. ',
                                                                      'type': 'MUintArray'}},
                                              'args': [('edgeIds',
                                                        'MUintArray',
                                                        'out'),
                                                       ('creaseData',
                                                        'MDoubleArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method returns the crease edges of the mesh, and also the crease data associated with those edges.',
                                              'inArgs': [],
                                              'inverse': ('setCreaseEdges',
                                                          False),
                                              'outArgs': ['edgeIds',
                                                          'creaseData'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'creaseData': ['&'],
                                                                 'edgeIds': ['&']},
                                              'types': {'creaseData': 'MDoubleArray',
                                                        'edgeIds': 'MUintArray'}}],
                          'getCreaseVertices': [{'argInfo': {'creaseData': {'doc': 'The data related to the crease vertices.',
                                                                            'type': 'MDoubleArray'},
                                                             'vertexIds': {'doc': 'The list of crease vertices ids. ',
                                                                           'type': 'MUintArray'}},
                                                 'args': [('vertexIds',
                                                           'MUintArray',
                                                           'out'),
                                                          ('creaseData',
                                                           'MDoubleArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method returns the crease vertices of the mesh, and also the crease data associated with those vertices.',
                                                 'inArgs': [],
                                                 'inverse': ('setCreaseVertices',
                                                             False),
                                                 'outArgs': ['vertexIds',
                                                             'creaseData'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'creaseData': ['&'],
                                                                    'vertexIds': ['&']},
                                                 'types': {'creaseData': 'MDoubleArray',
                                                           'vertexIds': 'MUintArray'}}],
                          'getDoubleBlindData': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The blind data id to check for ',
                                                                              'type': 'int'},
                                                              'compID': {'doc': 'The component to get for blind data on When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'int'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Space for the data item',
                                                                       'type': 'double'}},
                                                  'args': [('compID',
                                                            'int',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.',
                                                  'inArgs': ['compID',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName'],
                                                  'inverse': ('setDoubleBlindData',
                                                              False),
                                                  'outArgs': ['data'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compID': [],
                                                                     'compType': [],
                                                                     'data': ['&']},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compID': 'int',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'double'}},
                                                 {'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The blind data id to check for ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'Space for the component indexes of the items When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Space for the data items',
                                                                       'type': 'MDoubleArray'}},
                                                  'args': [('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('compIDs',
                                                            'MIntArray',
                                                            'out'),
                                                           ('data',
                                                            'MDoubleArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.',
                                                  'inArgs': ['compType',
                                                             'blindDataId',
                                                             'attrName'],
                                                  'inverse': ('setDoubleBlindData',
                                                              False),
                                                  'outArgs': ['compIDs',
                                                              'data'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': ['&']},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MDoubleArray'}}],
                          'getEdgeVertices': [{'argInfo': {'edgeId': {'doc': 'The edge to get the vertices for ',
                                                                      'type': 'int'},
                                                           'vertexList': {'doc': 'Storage for the 2 object-relative vertex indices',
                                                                          'type': 'int2'}},
                                               'args': [('edgeId',
                                                         'int',
                                                         'in'),
                                                        ('vertexList',
                                                         'int2',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nThis method retrieves the  object-relative (mesh-relative/global)  vertex indices corresponding to the specified edge. The indices can be used to refer to the elements in the array returned by the 'getPoints' method.",
                                               'inArgs': ['edgeId'],
                                               'outArgs': ['vertexList'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'edgeId': [],
                                                                  'vertexList': ['&']},
                                               'types': {'edgeId': 'int',
                                                         'vertexList': 'int2'}}],
                          'getFaceNormalIds': [{'argInfo': {'faceIndex': {'doc': 'Index of face (polygon) of interest ',
                                                                          'type': 'int'},
                                                            'normals': {'doc': 'Storage for the per-polygon normal ids',
                                                                        'type': 'MIntArray'}},
                                                'args': [('faceIndex',
                                                          'int',
                                                          'in'),
                                                         ('normals',
                                                          'MIntArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn normal indices for all vertices for a given face. The normalIds can be used to index into an array returned by  MFnMesh::getNormals() ;',
                                                'inArgs': ['faceIndex'],
                                                'outArgs': ['normals'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'faceIndex': [],
                                                                   'normals': ['&']},
                                                'types': {'faceIndex': 'int',
                                                          'normals': 'MIntArray'}}],
                          'getFaceUVSetNames': [{'argInfo': {'polygonId': {'doc': 'The polygon ID of the face of interest ',
                                                                           'type': 'int'},
                                                             'setNames': {'doc': 'The string array to return the UV sets names in',
                                                                          'type': 'MStringArray'}},
                                                 'args': [('polygonId',
                                                           'int',
                                                           'in'),
                                                          ('setNames',
                                                           'MStringArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method returns the list of UV sets mapped to a face.',
                                                 'inArgs': ['polygonId'],
                                                 'outArgs': ['setNames'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'polygonId': [],
                                                                    'setNames': ['&']},
                                                 'types': {'polygonId': 'int',
                                                           'setNames': 'MStringArray'}}],
                          'getFaceVertexBinormal': [{'argInfo': {'binormal': {'doc': 'Storage for the binormal. ',
                                                                              'type': 'MVector'},
                                                                 'faceIndex': {'doc': 'Index of the face of interest ',
                                                                               'type': 'int'},
                                                                 'space': {'doc': 'Specifies the coordinate system for this operation. ',
                                                                           'type': ('MSpace',
                                                                                    'Space')},
                                                                 'uvSet': {'doc': 'The uv map set to calculate the binormals aginst.',
                                                                           'type': 'MString'},
                                                                 'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index ',
                                                                                 'type': 'int'}},
                                                     'args': [('faceIndex',
                                                               'int',
                                                               'in'),
                                                              ('vertexIndex',
                                                               'int',
                                                               'in'),
                                                              ('binormal',
                                                               'MVector',
                                                               'out'),
                                                              ('space',
                                                               ('MSpace',
                                                                'Space'),
                                                               'in'),
                                                              ('uvSet',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {'space': ('MSpace',
                                                                            'Space',
                                                                            'kObject'),
                                                                  'uvSet': None},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn the binormal vector at a given face vertex.',
                                                     'inArgs': ['faceIndex',
                                                                'vertexIndex',
                                                                'space',
                                                                'uvSet'],
                                                     'outArgs': ['binormal'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'binormal': ['&'],
                                                                        'faceIndex': [],
                                                                        'space': [],
                                                                        'uvSet': ['const',
                                                                                  '*'],
                                                                        'vertexIndex': []},
                                                     'types': {'binormal': 'MVector',
                                                               'faceIndex': 'int',
                                                               'space': ('MSpace',
                                                                         'Space'),
                                                               'uvSet': 'MString',
                                                               'vertexIndex': 'int'}}],
                          'getFaceVertexBinormals': [{'argInfo': {'binormals': {'doc': 'Storage for the face binormals ',
                                                                                'type': 'MFloatVectorArray'},
                                                                  'faceIndex': {'doc': 'Index of the face (polygon) for which to retrive the binormals ',
                                                                                'type': 'int'},
                                                                  'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                            'type': ('MSpace',
                                                                                     'Space')},
                                                                  'uvSet': {'doc': 'The uv map set to calculate the binormals aginst.',
                                                                            'type': 'MString'}},
                                                      'args': [('faceIndex',
                                                                'int',
                                                                'in'),
                                                               ('binormals',
                                                                'MFloatVectorArray',
                                                                'out'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in'),
                                                               ('uvSet',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {'space': ('MSpace',
                                                                             'Space',
                                                                             'kObject'),
                                                                   'uvSet': None},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn all per-vertex-per-face binormals for a given face.',
                                                      'inArgs': ['faceIndex',
                                                                 'space',
                                                                 'uvSet'],
                                                      'outArgs': ['binormals'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'binormals': ['&'],
                                                                         'faceIndex': [],
                                                                         'space': [],
                                                                         'uvSet': ['const',
                                                                                   '*']},
                                                      'types': {'binormals': 'MFloatVectorArray',
                                                                'faceIndex': 'int',
                                                                'space': ('MSpace',
                                                                          'Space'),
                                                                'uvSet': 'MString'}}],
                          'getFaceVertexBlindDataIndex': [{'argInfo': {'blindDataIndex': {'doc': 'The component index for face vertex blind data storage to be returned',
                                                                                          'type': 'int'},
                                                                       'faceIndex': {'doc': 'The face index to look for ',
                                                                                     'type': 'int'},
                                                                       'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index ',
                                                                                       'type': 'int'}},
                                                           'args': [('faceIndex',
                                                                     'int',
                                                                     'in'),
                                                                    ('vertexIndex',
                                                                     'int',
                                                                     'in'),
                                                                    ('blindDataIndex',
                                                                     'int',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nGet the single index to retrieve face-vertex blind data.',
                                                           'inArgs': ['faceIndex',
                                                                      'vertexIndex'],
                                                           'outArgs': ['blindDataIndex'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'blindDataIndex': ['&'],
                                                                              'faceIndex': [],
                                                                              'vertexIndex': []},
                                                           'types': {'blindDataIndex': 'int',
                                                                     'faceIndex': 'int',
                                                                     'vertexIndex': 'int'}}],
                          'getFaceVertexColorIndex': [{'argInfo': {'colorIndex': {'doc': 'Storage for the color index to be returned. ',
                                                                                  'type': 'int'},
                                                                   'colorSet': {'doc': 'Color set to work with',
                                                                                'type': 'MString'},
                                                                   'faceIndex': {'doc': 'The face to look for ',
                                                                                 'type': 'int'},
                                                                   'localVertexIndex': {'doc': 'The face-relative (local) vertex id to look for ',
                                                                                        'type': 'int'}},
                                                       'args': [('faceIndex',
                                                                 'int',
                                                                 'in'),
                                                                ('localVertexIndex',
                                                                 'int',
                                                                 'in'),
                                                                ('colorIndex',
                                                                 'int',
                                                                 'out'),
                                                                ('colorSet',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {'colorSet': None},
                                                       'deprecated': False,
                                                       'doc': '\r\nGet an index into the array returned by getFaceVertexColors. So that you can index into the array directly, instead of walking it in face-vertex order.',
                                                       'inArgs': ['faceIndex',
                                                                  'localVertexIndex',
                                                                  'colorSet'],
                                                       'outArgs': ['colorIndex'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'colorIndex': ['&'],
                                                                          'colorSet': ['const',
                                                                                       '*'],
                                                                          'faceIndex': [],
                                                                          'localVertexIndex': []},
                                                       'types': {'colorIndex': 'int',
                                                                 'colorSet': 'MString',
                                                                 'faceIndex': 'int',
                                                                 'localVertexIndex': 'int'}}],
                          'getFaceVertexColors': [{'argInfo': {'colorSet': {'doc': 'Color set name ',
                                                                            'type': 'MString'},
                                                               'colors': {'doc': 'Storage for the colors to be returned. ',
                                                                          'type': 'MColorArray'},
                                                               'defaultUnsetColor': {'doc': 'Default unset color',
                                                                                     'type': 'MColor'}},
                                                   'args': [('colors',
                                                             'MColorArray',
                                                             'out'),
                                                            ('colorSet',
                                                             'MString',
                                                             'in'),
                                                            ('defaultUnsetColor',
                                                             'MColor',
                                                             'in')],
                                                   'defaults': {'colorSet': None,
                                                                'defaultUnsetColor': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet colors for all vertex/faces of the given color set. If the color set is not specified, the default color set will be used. If no vertex/face has color for that vertex, the entry returned will be defaultUnsetColor. If defaultUnsetColor is not given, then (-1, -1, -1, -1) will be used. If a color was set for some but not all the faces for that vertex, the ones where the color has not been explicitly set will have (0,0,0). If a vertex has shared color, the same value will be set for all its vertes/faces.',
                                                   'inArgs': ['colorSet',
                                                              'defaultUnsetColor'],
                                                   'inverse': ('setFaceVertexColors',
                                                               False),
                                                   'outArgs': ['colors'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'colorSet': ['const',
                                                                                   '*'],
                                                                      'colors': ['&'],
                                                                      'defaultUnsetColor': ['const',
                                                                                            '*']},
                                                   'types': {'colorSet': 'MString',
                                                             'colors': 'MColorArray',
                                                             'defaultUnsetColor': 'MColor'}}],
                          'getFaceVertexNormal': [{'argInfo': {'faceIndex': {'doc': 'Index of the face of interest ',
                                                                             'type': 'int'},
                                                               'normal': {'doc': 'Storage for the per-polygon-per-vertex normal ',
                                                                          'type': 'MVector'},
                                                               'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index ',
                                                                               'type': 'int'}},
                                                   'args': [('faceIndex',
                                                             'int',
                                                             'in'),
                                                            ('vertexIndex',
                                                             'int',
                                                             'in'),
                                                            ('normal',
                                                             'MVector',
                                                             'out'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject')},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn a per-vertex-per-face normal for a given face (polygon) and given vertex.',
                                                   'inArgs': ['faceIndex',
                                                              'vertexIndex',
                                                              'space'],
                                                   'inverse': None,
                                                   'outArgs': ['normal'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'faceIndex': [],
                                                                      'normal': ['&'],
                                                                      'space': [],
                                                                      'vertexIndex': []},
                                                   'types': {'faceIndex': 'int',
                                                             'normal': 'MVector',
                                                             'space': ('MSpace',
                                                                       'Space'),
                                                             'vertexIndex': 'int'}}],
                          'getFaceVertexNormals': [{'argInfo': {'faceIndex': {'doc': 'Index of the face (polygon) for which to retrive the normals ',
                                                                              'type': 'int'},
                                                                'normals': {'doc': 'Storage for the face normals ',
                                                                            'type': 'MFloatVectorArray'},
                                                                'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                          'type': ('MSpace',
                                                                                   'Space')}},
                                                    'args': [('faceIndex',
                                                              'int',
                                                              'in'),
                                                             ('normals',
                                                              'MFloatVectorArray',
                                                              'out'),
                                                             ('space',
                                                              ('MSpace',
                                                               'Space'),
                                                              'in')],
                                                    'defaults': {'space': ('MSpace',
                                                                           'Space',
                                                                           'kObject')},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn all per-vertex-per-face normals for a given face.',
                                                    'inArgs': ['faceIndex',
                                                               'space'],
                                                    'inverse': None,
                                                    'outArgs': ['normals'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'faceIndex': [],
                                                                       'normals': ['&'],
                                                                       'space': []},
                                                    'types': {'faceIndex': 'int',
                                                              'normals': 'MFloatVectorArray',
                                                              'space': ('MSpace',
                                                                        'Space')}}],
                          'getFaceVertexTangent': [{'argInfo': {'faceIndex': {'doc': 'Index of the face of interest. ',
                                                                              'type': 'int'},
                                                                'space': {'doc': 'Specifies the coordinate system for this operation. ',
                                                                          'type': ('MSpace',
                                                                                   'Space')},
                                                                'tangent': {'doc': 'Storage for the tangent. ',
                                                                            'type': 'MVector'},
                                                                'uvSet': {'doc': 'The uv map set to calculate the binormals aginst.',
                                                                          'type': 'MString'},
                                                                'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index. ',
                                                                                'type': 'int'}},
                                                    'args': [('faceIndex',
                                                              'int',
                                                              'in'),
                                                             ('vertexIndex',
                                                              'int',
                                                              'in'),
                                                             ('tangent',
                                                              'MVector',
                                                              'out'),
                                                             ('space',
                                                              ('MSpace',
                                                               'Space'),
                                                              'in'),
                                                             ('uvSet',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {'space': ('MSpace',
                                                                           'Space',
                                                                           'kObject'),
                                                                 'uvSet': None},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the normalized tangent vector at a given face vertex.',
                                                    'inArgs': ['faceIndex',
                                                               'vertexIndex',
                                                               'space',
                                                               'uvSet'],
                                                    'outArgs': ['tangent'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'faceIndex': [],
                                                                       'space': [],
                                                                       'tangent': ['&'],
                                                                       'uvSet': ['const',
                                                                                 '*'],
                                                                       'vertexIndex': []},
                                                    'types': {'faceIndex': 'int',
                                                              'space': ('MSpace',
                                                                        'Space'),
                                                              'tangent': 'MVector',
                                                              'uvSet': 'MString',
                                                              'vertexIndex': 'int'}}],
                          'getFaceVertexTangents': [{'argInfo': {'faceIndex': {'doc': 'Index of the face (polygon) for which to retrive the tangents ',
                                                                               'type': 'int'},
                                                                 'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                           'type': ('MSpace',
                                                                                    'Space')},
                                                                 'tangents': {'doc': 'Storage for the face tangents ',
                                                                              'type': 'MFloatVectorArray'},
                                                                 'uvSet': {'doc': 'The uv map set to calculate the tangents aginst.',
                                                                           'type': 'MString'}},
                                                     'args': [('faceIndex',
                                                               'int',
                                                               'in'),
                                                              ('tangents',
                                                               'MFloatVectorArray',
                                                               'out'),
                                                              ('space',
                                                               ('MSpace',
                                                                'Space'),
                                                               'in'),
                                                              ('uvSet',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {'space': ('MSpace',
                                                                            'Space',
                                                                            'kObject'),
                                                                  'uvSet': None},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn all per-vertex-per-face tangents for a given face.',
                                                     'inArgs': ['faceIndex',
                                                                'space',
                                                                'uvSet'],
                                                     'outArgs': ['tangents'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'faceIndex': [],
                                                                        'space': [],
                                                                        'tangents': ['&'],
                                                                        'uvSet': ['const',
                                                                                  '*']},
                                                     'types': {'faceIndex': 'int',
                                                               'space': ('MSpace',
                                                                         'Space'),
                                                               'tangents': 'MFloatVectorArray',
                                                               'uvSet': 'MString'}}],
                          'getFloatBlindData': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                          'type': 'MString'},
                                                             'blindDataId': {'doc': 'The blind data id to check for ',
                                                                             'type': 'int'},
                                                             'compID': {'doc': 'The component to get for blind data on When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                        'type': 'int'},
                                                             'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                          'type': ('MFn',
                                                                                   'Type')},
                                                             'data': {'doc': 'Space for the data item',
                                                                      'type': 'float'}},
                                                 'args': [('compID',
                                                           'int',
                                                           'in'),
                                                          ('compType',
                                                           ('MFn',
                                                            'Type'),
                                                           'in'),
                                                          ('blindDataId',
                                                           'int',
                                                           'in'),
                                                          ('attrName',
                                                           'MString',
                                                           'in'),
                                                          ('data',
                                                           'float',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.',
                                                 'inArgs': ['compID',
                                                            'compType',
                                                            'blindDataId',
                                                            'attrName'],
                                                 'inverse': ('setFloatBlindData',
                                                             False),
                                                 'outArgs': ['data'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'attrName': [],
                                                                    'blindDataId': [],
                                                                    'compID': [],
                                                                    'compType': [],
                                                                    'data': ['&']},
                                                 'types': {'attrName': 'MString',
                                                           'blindDataId': 'int',
                                                           'compID': 'int',
                                                           'compType': ('MFn',
                                                                        'Type'),
                                                           'data': 'float'}},
                                                {'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                          'type': 'MString'},
                                                             'blindDataId': {'doc': 'The blind data id to check for ',
                                                                             'type': 'int'},
                                                             'compIDs': {'doc': 'Space for the component indexes of the items When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'MIntArray'},
                                                             'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                          'type': ('MFn',
                                                                                   'Type')},
                                                             'data': {'doc': 'Space for the data items',
                                                                      'type': 'MFloatArray'}},
                                                 'args': [('compType',
                                                           ('MFn',
                                                            'Type'),
                                                           'in'),
                                                          ('blindDataId',
                                                           'int',
                                                           'in'),
                                                          ('attrName',
                                                           'MString',
                                                           'in'),
                                                          ('compIDs',
                                                           'MIntArray',
                                                           'out'),
                                                          ('data',
                                                           'MFloatArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.',
                                                 'inArgs': ['compType',
                                                            'blindDataId',
                                                            'attrName'],
                                                 'inverse': ('setFloatBlindData',
                                                             False),
                                                 'outArgs': ['compIDs',
                                                             'data'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'attrName': [],
                                                                    'blindDataId': [],
                                                                    'compIDs': ['&'],
                                                                    'compType': [],
                                                                    'data': ['&']},
                                                 'types': {'attrName': 'MString',
                                                           'blindDataId': 'int',
                                                           'compIDs': 'MIntArray',
                                                           'compType': ('MFn',
                                                                        'Type'),
                                                           'data': 'MFloatArray'}}],
                          'getHoles': [{'argInfo': {'holeInfoArray': {'doc': "Receives an array of integer triples, one for each hole in the mesh. The first element in each triple represents the index of the holed face. The next two elements represent the number of vertices in the hole and the hole's start index in list of hole vertices in holeVertexArray, respectively. For example, if holeInfoArray = [ 0, 3, 0, 1, 4, 3 ], then this means that face 0 contains a 3-vertex hole whose vertex indices are stored in elements 0, 1, 2 of holeVertexArray, and face 1 contains a 4-vertex hole whose vertex indices are stored in elements 3, 4, 5, 6 of holeVertexArray. ",
                                                                      'type': 'MIntArray'},
                                                    'holeVertexArray': {'doc': "Receives an array consisting of the vertex indices of every hole in the mesh. The third element of each triple in holeInfoArray is the index of the start of a particular hole's vertex list in this array. ",
                                                                        'type': 'MIntArray'}},
                                        'args': [('holeInfoArray',
                                                  'MIntArray',
                                                  'out'),
                                                 ('holeVertexArray',
                                                  'MIntArray',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nRetrieves a list of the holes in the polygon.',
                                        'inArgs': [],
                                        'outArgs': ['holeInfoArray',
                                                    'holeVertexArray'],
                                        'returnInfo': {'doc': 'The number of holes in the mesh.',
                                                       'qualifiers': [],
                                                       'type': 'int'},
                                        'returnType': 'int',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           'holeInfoArray': ['&'],
                                                           'holeVertexArray': ['&']},
                                        'types': {'holeInfoArray': 'MIntArray',
                                                  'holeVertexArray': 'MIntArray'}}],
                          'getIntBlindData': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                        'type': 'MString'},
                                                           'blindDataId': {'doc': 'The blind data id to check for ',
                                                                           'type': 'int'},
                                                           'compID': {'doc': 'The component to get for blind data on. When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                      'type': 'int'},
                                                           'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                        'type': ('MFn',
                                                                                 'Type')},
                                                           'data': {'doc': 'Space for the data item',
                                                                    'type': 'int'}},
                                               'args': [('compID',
                                                         'int',
                                                         'in'),
                                                        ('compType',
                                                         ('MFn',
                                                          'Type'),
                                                         'in'),
                                                        ('blindDataId',
                                                         'int',
                                                         'in'),
                                                        ('attrName',
                                                         'MString',
                                                         'in'),
                                                        ('data',
                                                         'int',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.',
                                               'inArgs': ['compID',
                                                          'compType',
                                                          'blindDataId',
                                                          'attrName'],
                                               'inverse': ('setIntBlindData',
                                                           False),
                                               'outArgs': ['data'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'attrName': [],
                                                                  'blindDataId': [],
                                                                  'compID': [],
                                                                  'compType': [],
                                                                  'data': ['&']},
                                               'types': {'attrName': 'MString',
                                                         'blindDataId': 'int',
                                                         'compID': 'int',
                                                         'compType': ('MFn',
                                                                      'Type'),
                                                         'data': 'int'}},
                                              {'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                        'type': 'MString'},
                                                           'blindDataId': {'doc': 'The blind data id to check for ',
                                                                           'type': 'int'},
                                                           'compIDs': {'doc': 'Space for the component indexes of the items When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                       'type': 'MIntArray'},
                                                           'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                        'type': ('MFn',
                                                                                 'Type')},
                                                           'data': {'doc': 'Space for the data items',
                                                                    'type': 'MIntArray'}},
                                               'args': [('compType',
                                                         ('MFn',
                                                          'Type'),
                                                         'in'),
                                                        ('blindDataId',
                                                         'int',
                                                         'in'),
                                                        ('attrName',
                                                         'MString',
                                                         'in'),
                                                        ('compIDs',
                                                         'MIntArray',
                                                         'out'),
                                                        ('data',
                                                         'MIntArray',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the blind data value for the specified blind data attribute of the given type of component. If the type of the attribute is not correct, this method will fail.',
                                               'inArgs': ['compType',
                                                          'blindDataId',
                                                          'attrName'],
                                               'inverse': ('setIntBlindData',
                                                           False),
                                               'outArgs': ['compIDs',
                                                           'data'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'attrName': [],
                                                                  'blindDataId': [],
                                                                  'compIDs': ['&'],
                                                                  'compType': [],
                                                                  'data': ['&']},
                                               'types': {'attrName': 'MString',
                                                         'blindDataId': 'int',
                                                         'compIDs': 'MIntArray',
                                                         'compType': ('MFn',
                                                                      'Type'),
                                                         'data': 'MIntArray'}}],
                          'getInvisibleFaces': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method returns the invisible faces of the mesh.',
                                                 'inArgs': [],
                                                 'inverse': ('setInvisibleFaces',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The list of invisible face ids.',
                                                                'qualifiers': [],
                                                                'type': 'MUintArray'},
                                                 'returnType': 'MUintArray',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                          'getNormalIds': [{'argInfo': {'normalCounts': {'doc': 'Number of normals for each face ',
                                                                         'type': 'MIntArray'},
                                                        'normals': {'doc': 'Storage for the per-polygon normal ids',
                                                                    'type': 'MIntArray'}},
                                            'args': [('normalCounts',
                                                      'MIntArray',
                                                      'out'),
                                                     ('normals',
                                                      'MIntArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn normal indices for all vertices for a all faces. The normalIds can be used to index into an array returned by  MFnMesh::getNormals() ;',
                                            'inArgs': [],
                                            'outArgs': ['normalCounts',
                                                        'normals'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'normalCounts': ['&'],
                                                               'normals': ['&']},
                                            'types': {'normalCounts': 'MIntArray',
                                                      'normals': 'MIntArray'}}],
                          'getNormals': [{'argInfo': {'normals': {'doc': 'Storage for the per-polygon per-vertex normal list ',
                                                                  'type': 'MFloatVectorArray'},
                                                      'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                'type': ('MSpace',
                                                                         'Space')}},
                                          'args': [('normals',
                                                    'MFloatVectorArray',
                                                    'out'),
                                                   ('space',
                                                    ('MSpace', 'Space'),
                                                    'in')],
                                          'defaults': {'space': ('MSpace',
                                                                 'Space',
                                                                 'kObject')},
                                          'deprecated': False,
                                          'doc': '\r\nThis method copies the normal list for this mesh into the given array. The normals are the per-polygon per-vertex normals. To find the normal for a particular vertex-face, use  getFaceNormalIds()  or  MItMeshPolygon::normalIndex  to get the index into the array.',
                                          'inArgs': ['space'],
                                          'inverse': ('setNormals',
                                                      False),
                                          'outArgs': ['normals'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'normals': ['&'],
                                                             'space': []},
                                          'types': {'normals': 'MFloatVectorArray',
                                                    'space': ('MSpace',
                                                              'Space')}}],
                          'getPinUVs': [{'argInfo': {'pinData': {'doc': 'The list of pin weights. ',
                                                                 'type': 'MDoubleArray'},
                                                     'uvIds': {'doc': 'The list of pin uvs ids. ',
                                                               'type': 'MUintArray'},
                                                     'uvSet': {'doc': 'UV set to work with.',
                                                               'type': 'MString'}},
                                         'args': [('uvIds',
                                                   'MUintArray',
                                                   'out'),
                                                  ('pinData',
                                                   'MDoubleArray',
                                                   'out'),
                                                  ('uvSet',
                                                   'MString',
                                                   'in')],
                                         'defaults': {'uvSet': None},
                                         'deprecated': False,
                                         'doc': '\r\nThis method returns the pin uvs of the mesh, and also the pin data associated with those uvs.',
                                         'inArgs': ['uvSet'],
                                         'inverse': ('setPinUVs', False),
                                         'outArgs': ['uvIds', 'pinData'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'pinData': ['&'],
                                                            'uvIds': ['&'],
                                                            'uvSet': ['const',
                                                                      '*']},
                                         'types': {'pinData': 'MDoubleArray',
                                                   'uvIds': 'MUintArray',
                                                   'uvSet': 'MString'}}],
                          'getPoint': [{'argInfo': {'pos': {'doc': 'Storage for the vertex ',
                                                            'type': 'MPoint'},
                                                    'space': {'doc': 'Specifies the coordinate system for this operation',
                                                              'type': ('MSpace',
                                                                       'Space')},
                                                    'vertexId': {'doc': 'The object-relative (mesh-relative/global) index of the vertex to retrieve ',
                                                                 'type': 'int'}},
                                        'args': [('vertexId',
                                                  'int',
                                                  'in'),
                                                 ('pos',
                                                  'MPoint',
                                                  'out'),
                                                 ('space',
                                                  ('MSpace', 'Space'),
                                                  'in')],
                                        'defaults': {'space': ('MSpace',
                                                               'Space',
                                                               'kObject')},
                                        'deprecated': False,
                                        'doc': "\r\nGet the position of the specified vertex in this mesh's vertex list.",
                                        'inArgs': ['vertexId', 'space'],
                                        'inverse': ('setPoint', False),
                                        'outArgs': ['pos'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'pos': ['&'],
                                                           'space': [],
                                                           'vertexId': []},
                                        'types': {'pos': 'MPoint',
                                                  'space': ('MSpace',
                                                            'Space'),
                                                  'vertexId': 'int'}}],
                          'getPointAtUV': [{'argInfo': {'polygonId': {'doc': 'Search for uv on this face ',
                                                                      'type': 'int'},
                                                        'space': {'doc': 'The coordinate system to return "toThisPoint" in ',
                                                                  'type': ('MSpace',
                                                                           'Space')},
                                                        'toThisPoint': {'doc': 'Space for the point ',
                                                                        'type': 'MPoint'},
                                                        'tolerance': {'doc': 'tolerance value to compare float data type',
                                                                      'type': 'float'},
                                                        'uvPoint': {'doc': 'The UV value to try to locate ',
                                                                    'type': 'float2'},
                                                        'uvSet': {'doc': 'UV set to work with ',
                                                                  'type': 'MString'}},
                                            'args': [('polygonId',
                                                      'int',
                                                      'in'),
                                                     ('toThisPoint',
                                                      'MPoint',
                                                      'out'),
                                                     ('uvPoint',
                                                      'float2',
                                                      'in'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in'),
                                                     ('tolerance',
                                                      'float',
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject'),
                                                         'tolerance': 0.0,
                                                         'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the position of the point at the given UV value in the current polygon.',
                                            'inArgs': ['polygonId',
                                                       'uvPoint',
                                                       'space',
                                                       'uvSet',
                                                       'tolerance'],
                                            'outArgs': ['toThisPoint'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'polygonId': [],
                                                               'space': [],
                                                               'toThisPoint': ['&'],
                                                               'tolerance': [],
                                                               'uvPoint': ['&'],
                                                               'uvSet': ['const',
                                                                         '*']},
                                            'types': {'polygonId': 'int',
                                                      'space': ('MSpace',
                                                                'Space'),
                                                      'toThisPoint': 'MPoint',
                                                      'tolerance': 'float',
                                                      'uvPoint': 'float2',
                                                      'uvSet': 'MString'}}],
                          'getPoints': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation',
                                                               'type': ('MSpace',
                                                                        'Space')},
                                                     'vertexArray': {'doc': 'Storage for the vertex list ',
                                                                     'type': 'MFloatPointArray'}},
                                         'args': [('vertexArray',
                                                   'MFloatPointArray',
                                                   'out'),
                                                  ('space',
                                                   ('MSpace', 'Space'),
                                                   'in')],
                                         'defaults': {'space': ('MSpace',
                                                                'Space',
                                                                'kObject')},
                                         'deprecated': False,
                                         'doc': '\r\nThis method copies the vertex list for this mesh into the given point array.',
                                         'inArgs': ['space'],
                                         'inverse': ('setPoints', False),
                                         'outArgs': ['vertexArray'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'space': [],
                                                            'vertexArray': ['&']},
                                         'types': {'space': ('MSpace',
                                                             'Space'),
                                                   'vertexArray': 'MFloatPointArray'}},
                                        {'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation',
                                                               'type': ('MSpace',
                                                                        'Space')},
                                                     'vertexArray': {'doc': 'Storage for the vertex list ',
                                                                     'type': 'MPointArray'}},
                                         'args': [('vertexArray',
                                                   'MPointArray',
                                                   'out'),
                                                  ('space',
                                                   ('MSpace', 'Space'),
                                                   'in')],
                                         'defaults': {'space': ('MSpace',
                                                                'Space',
                                                                'kObject')},
                                         'deprecated': False,
                                         'doc': '\r\nThis method copies the vertex list for this mesh into the given point array.',
                                         'inArgs': ['space'],
                                         'inverse': ('setPoints', False),
                                         'outArgs': ['vertexArray'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'space': [],
                                                            'vertexArray': ['&']},
                                         'types': {'space': ('MSpace',
                                                             'Space'),
                                                   'vertexArray': 'MPointArray'}}],
                          'getPointsAtUV': [{'argInfo': {'points': {'doc': 'Storage for the points on this surface to the given uv set and coordinate ',
                                                                    'type': 'MPointArray'},
                                                         'polygonIds': {'doc': 'Storage for polygon ids to the return points. ',
                                                                        'type': 'MIntArray'},
                                                         'space': {'doc': 'The coordinate system to return "points" in ',
                                                                   'type': ('MSpace',
                                                                            'Space')},
                                                         'tolerance': {'doc': 'tolerance value to compare float data type',
                                                                       'type': 'float'},
                                                         'uvPoint': {'doc': 'UV coordinate to be compared ',
                                                                     'type': 'float2'},
                                                         'uvSet': {'doc': 'UV set to work with ',
                                                                   'type': 'MString'}},
                                             'args': [('polygonIds',
                                                       'MIntArray',
                                                       'out'),
                                                      ('points',
                                                       'MPointArray',
                                                       'out'),
                                                      ('uvPoint',
                                                       'float2',
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in'),
                                                      ('uvSet',
                                                       'MString',
                                                       'in'),
                                                      ('tolerance',
                                                       'float',
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject'),
                                                          'tolerance': 0.0,
                                                          'uvSet': None},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the positions of the points at the given UV value on the mesh.',
                                             'inArgs': ['uvPoint',
                                                        'space',
                                                        'uvSet',
                                                        'tolerance'],
                                             'outArgs': ['polygonIds',
                                                         'points'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'points': ['&'],
                                                                'polygonIds': ['&'],
                                                                'space': [],
                                                                'tolerance': [],
                                                                'uvPoint': ['const',
                                                                            '&'],
                                                                'uvSet': ['const',
                                                                          '*']},
                                             'types': {'points': 'MPointArray',
                                                       'polygonIds': 'MIntArray',
                                                       'space': ('MSpace',
                                                                 'Space'),
                                                       'tolerance': 'float',
                                                       'uvPoint': 'float2',
                                                       'uvSet': 'MString'}}],
                          'getPolygonNormal': [{'argInfo': {'normal': {'doc': 'Storage for the per-polygon normal ',
                                                                       'type': 'MVector'},
                                                            'polygonId': {'doc': 'The polygon (face) to get the normal for ',
                                                                          'type': 'int'},
                                                            'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('polygonId',
                                                          'int',
                                                          'in'),
                                                         ('normal',
                                                          'MVector',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the normal at the given polygon. The returned normal is a per-polygon normal. See the class description for more information on normals.',
                                                'inArgs': ['polygonId',
                                                           'space'],
                                                'outArgs': ['normal'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'normal': ['&'],
                                                                   'polygonId': [],
                                                                   'space': []},
                                                'types': {'normal': 'MVector',
                                                          'polygonId': 'int',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                          'getPolygonTriangleVertices': [{'argInfo': {'polygonId': {'doc': 'The polygon to examine ',
                                                                                    'type': 'int'},
                                                                      'triangleId': {'doc': 'The triangle within the polygon to examine (numbered from zero) ',
                                                                                     'type': 'int'},
                                                                      'vertexList': {'doc': 'Storage for the vertex list. NOTE: Global (mesh-relative/object-relative) vertex indices are returned.',
                                                                                     'type': 'int__array3'}},
                                                          'args': [('polygonId',
                                                                    'int',
                                                                    'in'),
                                                                   ('triangleId',
                                                                    'int',
                                                                    'in'),
                                                                   ('vertexList',
                                                                    'int__array3',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\r\nThis method retrieves the  object-relative (mesh-relative/global)  vertex indices for the specified triangle in the specified polygon. The indices refer to the elements in the array returned by the 'getPoints' method.",
                                                          'inArgs': ['polygonId',
                                                                     'triangleId'],
                                                          'outArgs': ['vertexList'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'polygonId': [],
                                                                             'triangleId': [],
                                                                             'vertexList': []},
                                                          'types': {'polygonId': 'int',
                                                                    'triangleId': 'int',
                                                                    'vertexList': 'int__array3'}}],
                          'getPolygonUV': [{'argInfo': {'polygonId': {'doc': 'The polygon (face) to examine ',
                                                                      'type': 'int'},
                                                        'u': {'doc': 'Storage for the u value ',
                                                              'type': 'float'},
                                                        'uvSet': {'doc': 'UV set to work with',
                                                                  'type': 'MString'},
                                                        'v': {'doc': 'Storage for the v value ',
                                                              'type': 'float'},
                                                        'vertexIndex': {'doc': 'The face-relative (local) vertex id to examine ',
                                                                        'type': 'int'}},
                                            'args': [('polygonId',
                                                      'int',
                                                      'in'),
                                                     ('vertexIndex',
                                                      'int',
                                                      'in'),
                                                     ('u',
                                                      'float',
                                                      'out'),
                                                     ('v',
                                                      'float',
                                                      'out'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'uvSet': None},
                                            'deprecated': False,
                                            'doc': "\r\nGet the value of the specified texture coordinate for a vertex in a polygon. Since texture coordinates (uv's) are stored per-polygon per-vertex you must specify both the polygon and the vertex that the u and v values are mapped to.",
                                            'inArgs': ['polygonId',
                                                       'vertexIndex',
                                                       'uvSet'],
                                            'outArgs': ['u', 'v'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'polygonId': [],
                                                               'u': ['&'],
                                                               'uvSet': ['const',
                                                                         '*'],
                                                               'v': ['&'],
                                                               'vertexIndex': []},
                                            'types': {'polygonId': 'int',
                                                      'u': 'float',
                                                      'uvSet': 'MString',
                                                      'v': 'float',
                                                      'vertexIndex': 'int'}}],
                          'getPolygonUVid': [{'argInfo': {'polygonId': {'doc': 'The polygon (face) to examine ',
                                                                        'type': 'int'},
                                                          'uvId': {'doc': 'Storage for the uv index ',
                                                                   'type': 'int'},
                                                          'uvSet': {'doc': 'UV set to work with',
                                                                    'type': 'MString'},
                                                          'vertexIndex': {'doc': 'The face-relative (local) vertex id to examine ',
                                                                          'type': 'int'}},
                                              'args': [('polygonId',
                                                        'int',
                                                        'in'),
                                                       ('vertexIndex',
                                                        'int',
                                                        'in'),
                                                       ('uvId',
                                                        'int',
                                                        'out'),
                                                       ('uvSet',
                                                        'MString',
                                                        'in')],
                                              'defaults': {'uvSet': None},
                                              'deprecated': False,
                                              'doc': '\r\nGet the id of the specified texture coordinate for a vertex in a polygon.',
                                              'inArgs': ['polygonId',
                                                         'vertexIndex',
                                                         'uvSet'],
                                              'outArgs': ['uvId'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'polygonId': [],
                                                                 'uvId': ['&'],
                                                                 'uvSet': ['const',
                                                                           '*'],
                                                                 'vertexIndex': []},
                                              'types': {'polygonId': 'int',
                                                        'uvId': 'int',
                                                        'uvSet': 'MString',
                                                        'vertexIndex': 'int'}}],
                          'getPolygonVertices': [{'argInfo': {'polygonId': {'doc': 'The polygon to examine ',
                                                                            'type': 'int'},
                                                              'vertexList': {'doc': 'Storage for the vertex list. NOTE: Global (mesh-relative/object-relative) vertex indices are returned.',
                                                                             'type': 'MIntArray'}},
                                                  'args': [('polygonId',
                                                            'int',
                                                            'in'),
                                                           ('vertexList',
                                                            'MIntArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nThis method retrieves the  object-relative (mesh-relative/global)  vertex indices for the specified polygon. The indices refer to the elements in the array returned by the 'getPoints' method.",
                                                  'inArgs': ['polygonId'],
                                                  'outArgs': ['vertexList'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'polygonId': [],
                                                                     'vertexList': ['&']},
                                                  'types': {'polygonId': 'int',
                                                            'vertexList': 'MIntArray'}}],
                          'getRawDoublePoints': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method returns a pointer to the internal vertex list for this mesh. The points are in local space.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                          'getRawNormals': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis method returns a pointer to the internal normal list for this mesh. The normals are in local space and are the per-polygon per-vertex normals. To find the normal for a particular vertex-face, use  getFaceNormalIds()  or  MItMeshPolygon::normalIndex  to get the index into the array.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                          'getRawPoints': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method returns a pointer to the internal vertex list for this mesh. The points are in local space.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'float'},
                                            'returnType': 'float',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                          'getSmoothMeshDisplayOptions': [{'argInfo': {'options': {'doc': 'storge for the options',
                                                                                   'type': 'MMeshSmoothOptions'}},
                                                           'args': [('options',
                                                                     'MMeshSmoothOptions',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nRetrieve the current display smoothing options for the mesh',
                                                           'inArgs': [],
                                                           'inverse': ('setSmoothMeshDisplayOptions',
                                                                       False),
                                                           'outArgs': ['options'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'options': ['&']},
                                                           'types': {'options': 'MMeshSmoothOptions'}}],
                          'getStringBlindData': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The blind data id to check for ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'Space for the component indexes of the items When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': "Space for the data items (note that we return the bool data as an MIntArray since we don't have a convenient bool array type",
                                                                       'type': 'MStringArray'}},
                                                  'args': [('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('compIDs',
                                                            'MIntArray',
                                                            'out'),
                                                           ('data',
                                                            'MStringArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.',
                                                  'inArgs': ['compType',
                                                             'blindDataId',
                                                             'attrName'],
                                                  'inverse': ('setStringBlindData',
                                                              False),
                                                  'outArgs': ['compIDs',
                                                              'data'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': ['&']},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MStringArray'}}],
                          'getTangentId': [{'argInfo': {'faceIndex': {'doc': 'Index of the face of interest. ',
                                                                      'type': 'int'},
                                                        'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index. ',
                                                                        'type': 'int'}},
                                            'args': [('faceIndex',
                                                      'int',
                                                      'in'),
                                                     ('vertexIndex',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the tangent index for a given face vertex.',
                                            'inArgs': ['faceIndex',
                                                       'vertexIndex'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'faceIndex': [],
                                                               'vertexIndex': []},
                                            'types': {'faceIndex': 'int',
                                                      'vertexIndex': 'int'}}],
                          'getTangents': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation. ',
                                                                 'type': ('MSpace',
                                                                          'Space')},
                                                       'tangents': {'doc': 'Storage for the tangents. ',
                                                                    'type': 'MFloatVectorArray'},
                                                       'uvSet': {'doc': 'The uv map set to calculate the tangents against.',
                                                                 'type': 'MString'}},
                                           'args': [('tangents',
                                                     'MFloatVectorArray',
                                                     'out'),
                                                    ('space',
                                                     ('MSpace',
                                                      'Space'),
                                                     'in'),
                                                    ('uvSet',
                                                     'MString',
                                                     'in')],
                                           'defaults': {'space': ('MSpace',
                                                                  'Space',
                                                                  'kObject'),
                                                        'uvSet': None},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the tangent vectors for all face vertices. The tangent is defined as the surface tangent of the polygon running in the U direction defined by the uv map.',
                                           'inArgs': ['space', 'uvSet'],
                                           'outArgs': ['tangents'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'space': [],
                                                              'tangents': ['&'],
                                                              'uvSet': ['const',
                                                                        '*']},
                                           'types': {'space': ('MSpace',
                                                               'Space'),
                                                     'tangents': 'MFloatVectorArray',
                                                     'uvSet': 'MString'}}],
                          'getTriangleOffsets': [{'argInfo': {'triangleCounts': {'doc': 'The number of triangles for each polygon face ',
                                                                                 'type': 'MIntArray'},
                                                              'triangleIndices': {'doc': 'The index array for each triangle in face vertex space',
                                                                                  'type': 'MIntArray'}},
                                                  'args': [('triangleCounts',
                                                            'MIntArray',
                                                            'out'),
                                                           ('triangleIndices',
                                                            'MIntArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the number of triangles for every polygon face and the offset into the vertex indices array for each triangle vertex (see  getVertices() ). The triangleVertices array holds each vertex for each triangle in sequence, so it has three times as many elements as there are triangles. (i.e. three times the sum of the elements of the triangleCounts array)',
                                                  'inArgs': [],
                                                  'outArgs': ['triangleCounts',
                                                              'triangleIndices'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'triangleCounts': ['&'],
                                                                     'triangleIndices': ['&']},
                                                  'types': {'triangleCounts': 'MIntArray',
                                                            'triangleIndices': 'MIntArray'}}],
                          'getTriangles': [{'argInfo': {'triangleCounts': {'doc': 'The number of triangles for each polygon face ',
                                                                           'type': 'MIntArray'},
                                                        'triangleVertices': {'doc': 'The triangle vertex Ids for each triangle',
                                                                             'type': 'MIntArray'}},
                                            'args': [('triangleCounts',
                                                      'MIntArray',
                                                      'out'),
                                                     ('triangleVertices',
                                                      'MIntArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the number of triangles for every polygon face and the vertex Ids of each triangle vertex. The triangleVertices array holds each vertex for each triangle in sequence, so it has three times as many elements as there are triangles. (i.e. three times the sum of the elements of the triangleCounts array)',
                                            'inArgs': [],
                                            'outArgs': ['triangleCounts',
                                                        'triangleVertices'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'triangleCounts': ['&'],
                                                               'triangleVertices': ['&']},
                                            'types': {'triangleCounts': 'MIntArray',
                                                      'triangleVertices': 'MIntArray'}}],
                          'getUV': [{'argInfo': {'u': {'doc': 'Storage for the u value ',
                                                       'type': 'float'},
                                                 'uvId': {'doc': 'The element in the uv list to examine ',
                                                          'type': 'int'},
                                                 'uvSet': {'doc': 'UV set to work with',
                                                           'type': 'MString'},
                                                 'v': {'doc': 'Storage for the v value ',
                                                       'type': 'float'}},
                                     'args': [('uvId', 'int', 'in'),
                                              ('u', 'float', 'out'),
                                              ('v', 'float', 'out'),
                                              ('uvSet', 'MString', 'in')],
                                     'defaults': {'uvSet': None},
                                     'deprecated': False,
                                     'doc': "\r\nGet the value of the specified texture coordinate from this mesh's uv list. The uvId is the element in the uv list that will be retrieved.",
                                     'inArgs': ['uvId', 'uvSet'],
                                     'inverse': ('setUV', False),
                                     'outArgs': ['u', 'v'],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'u': ['&'],
                                                        'uvId': [],
                                                        'uvSet': ['const',
                                                                  '*'],
                                                        'v': ['&']},
                                     'types': {'u': 'float',
                                               'uvId': 'int',
                                               'uvSet': 'MString',
                                               'v': 'float'}}],
                          'getUVAtPoint': [{'argInfo': {'closestPolygon': {'doc': 'polygon id of the closest polygon',
                                                                           'type': 'int'},
                                                        'pt': {'doc': 'The point to try to get UV for ',
                                                               'type': 'MPoint'},
                                                        'space': {'doc': 'The coordinate system for this operation ',
                                                                  'type': ('MSpace',
                                                                           'Space')},
                                                        'uvPoint': {'doc': 'Space for the UV value ',
                                                                    'type': 'float2'},
                                                        'uvSet': {'doc': 'UV set to work with ',
                                                                  'type': 'MString'}},
                                            'args': [('pt',
                                                      'MPoint',
                                                      'in'),
                                                     ('uvPoint',
                                                      'float2',
                                                      'out'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in'),
                                                     ('closestPolygon',
                                                      'int',
                                                      'out')],
                                            'defaults': {'closestPolygon': None,
                                                         'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject'),
                                                         'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nFind the point closest to the given point, and return the UV value at that point.',
                                            'inArgs': ['pt',
                                                       'space',
                                                       'uvSet'],
                                            'outArgs': ['uvPoint',
                                                        'closestPolygon'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'closestPolygon': ['*'],
                                                               'pt': ['&'],
                                                               'space': [],
                                                               'uvPoint': ['&'],
                                                               'uvSet': ['const',
                                                                         '*']},
                                            'types': {'closestPolygon': 'int',
                                                      'pt': 'MPoint',
                                                      'space': ('MSpace',
                                                                'Space'),
                                                      'uvPoint': 'float2',
                                                      'uvSet': 'MString'}}],
                          'getUVSetFamilyNames': [{'argInfo': {'familyNames': {'doc': 'Array of uv set names found',
                                                                               'type': 'MStringArray'}},
                                                   'args': [('familyNames',
                                                             'MStringArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the names of all of the uv set families on this object. A uv set family is a set of per-instance sets with the same name with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family.',
                                                   'inArgs': [],
                                                   'outArgs': ['familyNames'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'familyNames': ['&']},
                                                   'types': {'familyNames': 'MStringArray'}}],
                          'getUVSetNames': [{'argInfo': {'setNames': {'doc': 'Array of uv set names found',
                                                                      'type': 'MStringArray'}},
                                             'args': [('setNames',
                                                       'MStringArray',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the names of all of the uv sets on this object.',
                                             'inArgs': [],
                                             'outArgs': ['setNames'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'setNames': ['&']},
                                             'types': {'setNames': 'MStringArray'}}],
                          'getUVSetsInFamily': [{'argInfo': {'familyName': {'doc': 'The uv set family name ',
                                                                            'type': 'MString'},
                                                             'setNames': {'doc': 'Array of uv set names in the family',
                                                                          'type': 'MStringArray'}},
                                                 'args': [('familyName',
                                                           'MString',
                                                           'in'),
                                                          ('setNames',
                                                           'MStringArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the names of the uv sets that belong to this set family. Per-instance sets will have multiple sets in a family, with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family and will share the same name as its family.',
                                                 'inArgs': ['familyName'],
                                                 'outArgs': ['setNames'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'familyName': ['const',
                                                                                   '&'],
                                                                    'setNames': ['&']},
                                                 'types': {'familyName': 'MString',
                                                           'setNames': 'MStringArray'}}],
                          'getUVs': [{'argInfo': {'uArray': {'doc': 'Storage for the u texture coordinate list ',
                                                             'type': 'MFloatArray'},
                                                  'uvSet': {'doc': 'UV set to work with',
                                                            'type': 'MString'},
                                                  'vArray': {'doc': 'Storage for the v texture coordinate list ',
                                                             'type': 'MFloatArray'}},
                                      'args': [('uArray',
                                                'MFloatArray',
                                                'out'),
                                               ('vArray',
                                                'MFloatArray',
                                                'out'),
                                               ('uvSet',
                                                'MString',
                                                'in')],
                                      'defaults': {'uvSet': None},
                                      'deprecated': False,
                                      'doc': '\r\nThis method copies the texture coordinate list for this mesh into the given uv arrays.',
                                      'inArgs': ['uvSet'],
                                      'inverse': ('setUVs', False),
                                      'outArgs': ['uArray', 'vArray'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'uArray': ['&'],
                                                         'uvSet': ['const',
                                                                   '*'],
                                                         'vArray': ['&']},
                                      'types': {'uArray': 'MFloatArray',
                                                'uvSet': 'MString',
                                                'vArray': 'MFloatArray'}}],
                          'getUvShellsIds': [{'argInfo': {'nbUvShells': {'doc': 'The number of UV shells in this UV set. ',
                                                                         'type': 'uint'},
                                                          'uvSet': {'doc': 'UV set to work with',
                                                                    'type': 'MString'},
                                                          'uvShellIds': {'doc': 'The container for the uv shell Ids ',
                                                                         'type': 'MIntArray'}},
                                              'args': [('uvShellIds',
                                                        'MIntArray',
                                                        'out'),
                                                       ('nbUvShells',
                                                        'uint',
                                                        'out'),
                                                       ('uvSet',
                                                        'MString',
                                                        'in')],
                                              'defaults': {'uvSet': None},
                                              'deprecated': False,
                                              'doc': '\r\nConstructs an array of unique integer for each UV shell. This method let the user identify each connected piece of UV.',
                                              'inArgs': ['uvSet'],
                                              'outArgs': ['uvShellIds',
                                                          'nbUvShells'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'nbUvShells': ['unsigned',
                                                                                '&'],
                                                                 'uvSet': ['const',
                                                                           '*'],
                                                                 'uvShellIds': ['&']},
                                              'types': {'nbUvShells': 'uint',
                                                        'uvSet': 'MString',
                                                        'uvShellIds': 'MIntArray'}}],
                          'getVertexColors': [{'argInfo': {'colorSet': {'doc': 'Color set name ',
                                                                        'type': 'MString'},
                                                           'colors': {'doc': 'Storage for the colors to be returned. ',
                                                                      'type': 'MColorArray'},
                                                           'defaultUnsetColor': {'doc': 'Default Unset color',
                                                                                 'type': 'MColor'}},
                                               'args': [('colors',
                                                         'MColorArray',
                                                         'out'),
                                                        ('colorSet',
                                                         'MString',
                                                         'in'),
                                                        ('defaultUnsetColor',
                                                         'MColor',
                                                         'in')],
                                               'defaults': {'colorSet': None,
                                                            'defaultUnsetColor': None},
                                               'deprecated': False,
                                               'doc': '\r\nGet colors for all Vertices of the given colorSet. If the colorSet is not specified, the default color set will be used. If no vertex/face has color for that vertex, the entry returned will be defaultUnsetColor. If the defaultUnsetColor is not given, then (-1, -1, -1, -1) will be used. If a color was set for some or all the faces for that vertex, an average of those verted/face values where the color has been set will be returned.',
                                               'inArgs': ['colorSet',
                                                          'defaultUnsetColor'],
                                               'inverse': ('setVertexColors',
                                                           False),
                                               'outArgs': ['colors'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'colorSet': ['const',
                                                                               '*'],
                                                                  'colors': ['&'],
                                                                  'defaultUnsetColor': ['const',
                                                                                        '*']},
                                               'types': {'colorSet': 'MString',
                                                         'colors': 'MColorArray',
                                                         'defaultUnsetColor': 'MColor'}}],
                          'getVertexNormal': [{'argInfo': {'normal': {'doc': 'Storage for the per-vertex normal ',
                                                                      'type': 'MVector'},
                                                           'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                     'type': ('MSpace',
                                                                              'Space')},
                                                           'vertexId': {'doc': 'The object-relative (mesh-relative/global) vertex index to get the normal for ',
                                                                        'type': 'int'}},
                                               'args': [('vertexId',
                                                         'int',
                                                         'in'),
                                                        ('normal',
                                                         'MVector',
                                                         'out'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': True,
                                               'doc': '\n This method is obsolete. \n',
                                               'inArgs': ['vertexId',
                                                          'space'],
                                               'inverse': ('setVertexNormal',
                                                           False),
                                               'outArgs': ['normal'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'normal': ['&'],
                                                                  'space': [],
                                                                  'vertexId': []},
                                               'types': {'normal': 'MVector',
                                                         'space': ('MSpace',
                                                                   'Space'),
                                                         'vertexId': 'int'}},
                                              {'argInfo': {'angleWeighted': {'doc': 'Defines algorithm used to compute normal ',
                                                                             'type': 'bool'},
                                                           'normal': {'doc': 'Storage for the per-vertex normal ',
                                                                      'type': 'MVector'},
                                                           'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                     'type': ('MSpace',
                                                                              'Space')},
                                                           'vertexId': {'doc': 'The object-relative (mesh-relative/global) vertex index to get the normal for ',
                                                                        'type': 'int'}},
                                               'args': [('vertexId',
                                                         'int',
                                                         'in'),
                                                        ('angleWeighted',
                                                         'bool',
                                                         'in'),
                                                        ('normal',
                                                         'MVector',
                                                         'out'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the normal at the given vertex. The returned normal is a single per-vertex normal, so unshared normals at a vertex will be averaged. See the class description for more information on normals.',
                                               'inArgs': ['vertexId',
                                                          'angleWeighted',
                                                          'space'],
                                               'inverse': ('setVertexNormal',
                                                           False),
                                               'outArgs': ['normal'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'angleWeighted': [],
                                                                  'normal': ['&'],
                                                                  'space': [],
                                                                  'vertexId': []},
                                               'types': {'angleWeighted': 'bool',
                                                         'normal': 'MVector',
                                                         'space': ('MSpace',
                                                                   'Space'),
                                                         'vertexId': 'int'}}],
                          'getVertexNormals': [{'argInfo': {'angleWeighted': {'doc': 'Defines algorithm used to compute normal ',
                                                                              'type': 'bool'},
                                                            'normals': {'doc': 'Storage for the per-vertex normals ',
                                                                        'type': 'MFloatVectorArray'},
                                                            'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('angleWeighted',
                                                          'bool',
                                                          'in'),
                                                         ('normals',
                                                          'MFloatVectorArray',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturn all vertex normals. The returned normals are per-vertex normals, so unshared normals at a vertex will be averaged. See the class description for more information on normals.',
                                                'inArgs': ['angleWeighted',
                                                           'space'],
                                                'inverse': ('setVertexNormals',
                                                            False),
                                                'outArgs': ['normals'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'angleWeighted': [],
                                                                   'normals': ['&'],
                                                                   'space': []},
                                                'types': {'angleWeighted': 'bool',
                                                          'normals': 'MFloatVectorArray',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                          'getVertices': [{'argInfo': {'vertexCount': {'doc': 'Vertex count per polygon ',
                                                                       'type': 'MIntArray'},
                                                       'vertexList': {'doc': 'Storage for the vertex list. NOTE: Global (mesh-relative/object-relative) vertex indices are returned.',
                                                                      'type': 'MIntArray'}},
                                           'args': [('vertexCount',
                                                     'MIntArray',
                                                     'out'),
                                                    ('vertexList',
                                                     'MIntArray',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\r\nThis method retrieves the  object-relative (mesh-relative/global)  vertex indices for all polygons. The indices refer to the elements in the array returned by the 'getPoints' method.",
                                           'inArgs': [],
                                           'outArgs': ['vertexCount',
                                                       'vertexList'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'vertexCount': ['&'],
                                                              'vertexList': ['&']},
                                           'types': {'vertexCount': 'MIntArray',
                                                     'vertexList': 'MIntArray'}}],
                          'globalIntersectionAcceleratorsInfo': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nRetrieves a string that describes the systemwide resource usage for cached mesh intersection accelerators. The string will be formatted similar to:',
                                                                  'inArgs': [],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': 'MString'},
                                                                  'returnType': 'MString',
                                                                  'static': True,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                          'hasAlphaChannels': [{'argInfo': {'colorSet': {'doc': 'Color set to work with ',
                                                                         'type': 'MString'}},
                                                'args': [('colorSet',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis method returns true if the color set has Alpha component.',
                                                'inArgs': ['colorSet'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': " true The color set has Alpha component  false The color set doesn't have Alpha component  ",
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'colorSet': ['const',
                                                                                '&']},
                                                'types': {'colorSet': 'MString'}}],
                          'hasBlindData': [{'argInfo': {'blindDataId': {'doc': 'The blind data id to check for ',
                                                                        'type': 'int'},
                                                        'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                     'type': ('MFn',
                                                                              'Type')}},
                                            'args': [('compType',
                                                      ('MFn', 'Type'),
                                                      'in'),
                                                     ('blindDataId',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if any component of the given type on this mesh have blind data with the given ID.',
                                            'inArgs': ['compType',
                                                       'blindDataId'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true: has the specified blind data, false: does not',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'blindDataId': [],
                                                               'compType': []},
                                            'types': {'blindDataId': 'int',
                                                      'compType': ('MFn',
                                                                   'Type')}},
                                           {'argInfo': {'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                     'type': ('MFn',
                                                                              'Type')}},
                                            'args': [('compType',
                                                      ('MFn', 'Type'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDoes any component of this type have any blind data. (.e. is there any vertex blind data on this mesh?)',
                                            'inArgs': ['compType'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true: has the specified blind data, false: does not',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'compType': []},
                                            'types': {'compType': ('MFn',
                                                                   'Type')}}],
                          'hasBlindDataComponentId': [{'argInfo': {'blindDataId': {'doc': 'The blind data id to check for ',
                                                                                   'type': 'int'},
                                                                   'compID': {'doc': 'The component to check for blind data om When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                              'type': 'int'},
                                                                   'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                                'type': ('MFn',
                                                                                         'Type')}},
                                                       'args': [('compID',
                                                                 'int',
                                                                 'in'),
                                                                ('compType',
                                                                 ('MFn',
                                                                  'Type'),
                                                                 'in'),
                                                                ('blindDataId',
                                                                 'int',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nDoes this component have blind data with the given ID.',
                                                       'inArgs': ['compID',
                                                                  'compType',
                                                                  'blindDataId'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'true: has the specified blind data, false: does not',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'blindDataId': [],
                                                                          'compID': [],
                                                                          'compType': []},
                                                       'types': {'blindDataId': 'int',
                                                                 'compID': 'int',
                                                                 'compType': ('MFn',
                                                                              'Type')}},
                                                      {'argInfo': {'compID': {'doc': 'The component to check for blind data on When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                              'type': 'int'},
                                                                   'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                                'type': ('MFn',
                                                                                         'Type')}},
                                                       'args': [('compID',
                                                                 'int',
                                                                 'in'),
                                                                ('compType',
                                                                 ('MFn',
                                                                  'Type'),
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nDoes this component have any kind of blind data',
                                                       'inArgs': ['compID',
                                                                  'compType'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'true: has the specified blind data, false: does not',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'compID': [],
                                                                          'compType': []},
                                                       'types': {'compID': 'int',
                                                                 'compType': ('MFn',
                                                                              'Type')}}],
                          'hasColorChannels': [{'argInfo': {'colorSet': {'doc': 'Color set to work with ',
                                                                         'type': 'MString'}},
                                                'args': [('colorSet',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis method returns if the color set has RGB components.',
                                                'inArgs': ['colorSet'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': " true The color set has RGB components  false The color set doesn't have RGB components  ",
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'colorSet': ['const',
                                                                                '&']},
                                                'types': {'colorSet': 'MString'}}],
                          'intersect': [{'argInfo': {'points': {'doc': 'Storage for any points of intersection ',
                                                                'type': 'MPointArray'},
                                                     'polygonIds': {'doc': "Storage for the polygon id's that correspond to the points of intersection. ",
                                                                    'type': 'MIntArray'},
                                                     'rayDirection': {'doc': 'Direction of the ray ',
                                                                      'type': 'MVector'},
                                                     'raySource': {'doc': 'Starting point for the ray ',
                                                                   'type': 'MPoint'},
                                                     'space': {'doc': 'specifies the coordinate system for this operation ',
                                                               'type': ('MSpace',
                                                                        'Space')},
                                                     'tolerance': {'doc': 'Tolerance used in intersection calculation ',
                                                                   'type': 'double'}},
                                         'args': [('raySource',
                                                   'MPoint',
                                                   'in'),
                                                  ('rayDirection',
                                                   'MVector',
                                                   'in'),
                                                  ('points',
                                                   'MPointArray',
                                                   'out'),
                                                  ('tolerance',
                                                   'double',
                                                   'in'),
                                                  ('space',
                                                   ('MSpace', 'Space'),
                                                   'in'),
                                                  ('polygonIds',
                                                   'MIntArray',
                                                   'out')],
                                         'defaults': {'polygonIds': None,
                                                      'space': ('MSpace',
                                                                'Space',
                                                                'kObject'),
                                                      'tolerance': 1e-10},
                                         'deprecated': False,
                                         'doc': '\r\nDetermines whether the given ray intersects this polygon and if so, returns the points of intersection. The points of intersection will be in order of closest point to the raySource.',
                                         'inArgs': ['raySource',
                                                    'rayDirection',
                                                    'tolerance',
                                                    'space'],
                                         'outArgs': ['points',
                                                     'polygonIds'],
                                         'returnInfo': {'doc': ' true The given ray intersects this polygon  false The given ray does not intersect this polygon  ',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'points': ['&'],
                                                            'polygonIds': ['*'],
                                                            'rayDirection': ['const',
                                                                             '&'],
                                                            'raySource': ['const',
                                                                          '&'],
                                                            'space': [],
                                                            'tolerance': []},
                                         'types': {'points': 'MPointArray',
                                                   'polygonIds': 'MIntArray',
                                                   'rayDirection': 'MVector',
                                                   'raySource': 'MPoint',
                                                   'space': ('MSpace',
                                                             'Space'),
                                                   'tolerance': 'double'}}],
                          'intersectFaceAtUV': [{'argInfo': {'faceId': {'doc': 'Intersected face ID ',
                                                                        'type': 'int'},
                                                             'toThisUVPoint': {'doc': 'UV coordinate to be compared ',
                                                                               'type': 'float2'},
                                                             'uvSet': {'doc': 'UV set to work with',
                                                                       'type': 'MString'}},
                                                 'args': [('toThisUVPoint',
                                                           'float2',
                                                           'in'),
                                                          ('faceId',
                                                           'int',
                                                           'out'),
                                                          ('uvSet',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {'uvSet': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns ID of the intersected face at given uv set and coordinate. If multiple faces are intersected, the first intersected one would be returned.',
                                                 'inArgs': ['toThisUVPoint',
                                                            'uvSet'],
                                                 'outArgs': ['faceId'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'faceId': ['&'],
                                                                    'toThisUVPoint': ['const',
                                                                                      '&'],
                                                                    'uvSet': ['const',
                                                                              '*']},
                                                 'types': {'faceId': 'int',
                                                           'toThisUVPoint': 'float2',
                                                           'uvSet': 'MString'}}],
                          'isBlindDataTypeUsed': [{'argInfo': {'blindDataId': {'doc': 'The blind data id to check for ',
                                                                               'type': 'int'}},
                                                   'args': [('blindDataId',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nIs this BlindData type id is already in use in this scene?',
                                                   'inArgs': ['blindDataId'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'true: Id in use, false: id not in use',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'blindDataId': []},
                                                   'types': {'blindDataId': 'int'}}],
                          'isColorClamped': [{'argInfo': {'colorSet': {'doc': 'Color set to work with ',
                                                                       'type': 'MString'}},
                                              'args': [('colorSet',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method returns if the color set has its R,G,B,and A components clamped in the range from 0 to 1.',
                                              'inArgs': ['colorSet'],
                                              'inverse': ('setIsColorClamped',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': ' true All components in the color set are clamped  false All components in the color set are not clamped  ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'colorSet': ['const',
                                                                              '&']},
                                              'types': {'colorSet': 'MString'}}],
                          'isColorSetPerInstance': [{'argInfo': {'name': {'doc': 'The set name or set family name ',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn true if this color set is per-instance, and false if it is shared across all instances. The name provided may be an individual set name or a set family name.',
                                                     'inArgs': ['name'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'true if the set is per-instance',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'name': ['const',
                                                                                 '&']},
                                                     'types': {'name': 'MString'}}],
                          'isEdgeSmooth': [{'argInfo': {'edgeId': {'doc': 'The edge to be tested ',
                                                                   'type': 'int'}},
                                            'args': [('edgeId',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method determines if the specified edge is smooth (soft).',
                                            'inArgs': ['edgeId'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true The edge is smooth (soft)  false The edge is hard  ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'edgeId': []},
                                            'types': {'edgeId': 'int'}}],
                          'isNormalLocked': [{'argInfo': {'normalId': {'doc': 'Normal to test. ',
                                                                       'type': 'int'}},
                                              'args': [('normalId',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nTest if the normal for a face/vertex pairs is locked (user defined).',
                                              'inArgs': ['normalId'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'true if the normal is locked. false if not locked.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'normalId': []},
                                              'types': {'normalId': 'int'}}],
                          'isPolygonConvex': [{'argInfo': {'faceIndex': {'doc': 'The polygon to be tested ',
                                                                         'type': 'int'}},
                                               'args': [('faceIndex',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method determines if the specified polygon is convex.',
                                               'inArgs': ['faceIndex'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': ' true The polygon is convex  false The edge is concave  ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'faceIndex': []},
                                               'types': {'faceIndex': 'int'}}],
                          'isPolygonUVReversed': [{'argInfo': {'polygonId': {'doc': 'The polygon to be tested ',
                                                                             'type': 'int'},
                                                               'uvSet': {'doc': 'UV set to work with ',
                                                                         'type': 'MString'}},
                                                   'args': [('polygonId',
                                                             'int',
                                                             'in'),
                                                            ('uvSet',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {'uvSet': None},
                                                   'deprecated': False,
                                                   'doc': "\r\nThis method determines if the winding order of texture coordinates (uv's) for specified polygon are reversed (clockwise)",
                                                   'inArgs': ['polygonId',
                                                              'uvSet'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': " true The texture coordinates (uv's) are reversed (clockwise)  false The texture coordinates (uv's) are not reversed (counter clockwise)  ",
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'polygonId': [],
                                                                      'uvSet': ['const',
                                                                                '*']},
                                                   'types': {'polygonId': 'int',
                                                             'uvSet': 'MString'}}],
                          'isRightHandedTangent': [{'argInfo': {'tangentId': {'doc': 'tangent index for a given face vertex ',
                                                                              'type': 'int'},
                                                                'uvSetName': {'doc': 'Name of uv set to use ',
                                                                              'type': 'MString'}},
                                                    'args': [('tangentId',
                                                              'int',
                                                              'in'),
                                                             ('uvSetName',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {'uvSetName': None},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns true if the normal, tangent and binormal form a right handed coordinate system. By default, Maya uses a right-handed system. Mirrored geometry can introduce a left-handed system.',
                                                    'inArgs': ['tangentId',
                                                               'uvSetName'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': ' true normal, tangent, and binormal are right handed  false normal, tangent, and binormal are left handed  ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'tangentId': [],
                                                                       'uvSetName': ['const',
                                                                                     '*']},
                                                    'types': {'tangentId': 'int',
                                                              'uvSetName': 'MString'}}],
                          'isUVSetPerInstance': [{'argInfo': {'name': {'doc': 'The set name or set family name ',
                                                                       'type': 'MString'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn true if this set is per-instance, and false if it is shared across all instances. The name provided may be an individual set name or a set family name.',
                                                  'inArgs': ['name'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the set is per-instance',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'name': ['const',
                                                                              '&']},
                                                  'types': {'name': 'MString'}}],
                          'lockFaceVertexNormals': [{'argInfo': {'faceList': {'doc': 'The faces to lock normal in ',
                                                                              'type': 'MIntArray'},
                                                                 'vertexList': {'doc': 'The corresponding object-relative (global) vertex indices to lock them for',
                                                                                'type': 'MIntArray'}},
                                                     'args': [('faceList',
                                                               'MIntArray',
                                                               'in'),
                                                              ('vertexList',
                                                               'MIntArray',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nLock Normals for these face/vertex pairs',
                                                     'inArgs': ['faceList',
                                                                'vertexList'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'faceList': ['&'],
                                                                        'vertexList': ['&']},
                                                     'types': {'faceList': 'MIntArray',
                                                               'vertexList': 'MIntArray'}}],
                          'lockVertexNormals': [{'argInfo': {'vertexList': {'doc': 'The object-relative (global) verticex ides to lock normals for',
                                                                            'type': 'MIntArray'}},
                                                 'args': [('vertexList',
                                                           'MIntArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nLock Shared Normals for these vertices.',
                                                 'inArgs': ['vertexList'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'vertexList': ['&']},
                                                 'types': {'vertexList': 'MIntArray'}}],
                          'numColorSets': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the number of color sets for an object.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The number of color sets for the object',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                          'numColors': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the number of (vertex) color for this mesh. The color are stored in a list which is referenced by polygons requiring color on a per-polygon per-vertex basis. This method returns the number of elements in this list.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of colors',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}},
                                        {'argInfo': {'colorSet': {'doc': 'Color set to work with ',
                                                                  'type': 'MString'}},
                                         'args': [('colorSet',
                                                   'MString',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the number of colors (vertex data) for this mesh. The colors are stored in a list which is referenced by polygons requiring textures on a per-polygon per-vertex basis. This method returns the number of elements in this list.',
                                         'inArgs': ['colorSet'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of colors',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'colorSet': ['const',
                                                                         '&']},
                                         'types': {'colorSet': 'MString'}}],
                          'numEdges': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the number of edges for this mesh.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The number of edges for this mesh',
                                                       'qualifiers': [],
                                                       'type': 'int'},
                                        'returnType': 'int',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                          'numFaceVertices': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the number of face-vertices for this mesh.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The number of face-vertices for this mesh',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'numNormals': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the number of per-polygon per-vertex normals for this mesh. This number will correspond to the length of the normal array returned by getNormals( normalArray, space ).',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The number of per-polygon per-vertex normals',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                          'numPolygons': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the number of polygons for this mesh.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of polygons for this mesh',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                          'numUVSets': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the number of uv sets for an object.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of uv sets for the object',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'numUVs': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nReturns the number of texture (uv) coordinates for this mesh. The uv's are stored in a list which is referenced by polygons requiring textures on a per-polygon per-vertex basis. This method returns the number of elements in this list.",
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The number of texture coordinates',
                                                     'qualifiers': [],
                                                     'type': 'int'},
                                      'returnType': 'int',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}},
                                     {'argInfo': {'uvSet': {'doc': 'UV set to work with ',
                                                            'type': 'MString'}},
                                      'args': [('uvSet',
                                                'MString',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nReturns the number of texture (uv) coordinates for this mesh. The uv's are stored in a list which is referenced by polygons requiring textures on a per-polygon per-vertex basis. This method returns the number of elements in this list.",
                                      'inArgs': ['uvSet'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The number of texture coordinates',
                                                     'qualifiers': [],
                                                     'type': 'int'},
                                      'returnType': 'int',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'uvSet': ['const',
                                                                   '&']},
                                      'types': {'uvSet': 'MString'}}],
                          'numVertices': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the number of vertices in the vertex list for this mesh. This number will be the same as the length of the vertex array returned with the getPoints method.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of vertices of the mesh',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                          'onBoundary': [{'argInfo': {'polygonId': {'doc': 'The polygon (face) to examine ',
                                                                    'type': 'int'}},
                                          'args': [('polygonId',
                                                    'int',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nA method to determines whether the specified face in the mesh is a boundary face.',
                                          'inArgs': ['polygonId'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true If the specified edge is on the border of the object.  false If the specified edge is not on the boundary of the object.  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'polygonId': []},
                                          'types': {'polygonId': 'int'}}],
                          'polyTriangulate': [{'argInfo': {'considerNormal': {'doc': 'If true then normals are considered during triangulation ',
                                                                              'type': 'bool'},
                                                           'holesCount': {'doc': 'The number of holes in pointsAndHoles ',
                                                                          'type': 'uint'},
                                                           'normals': {'doc': 'Array of 3D normals. If considerNormal is false, this array can be nullptr. If considerNormal is true, then there must be one normal per point. ',
                                                                       'type': 'float'},
                                                           'outerPointsCount': {'doc': 'The number of outer (non-hole) 2D positions in pointsAndHoles ',
                                                                                'type': 'uint'},
                                                           'pointsAndHoles': {'doc': 'Array of 2D positions and hole description. The array contains 2D positions (x,y) followed by the hole offsets. For example, if pointsAndHoles = [x1, y1, x2, y2, ..., x9, y9, o1, o1, o2, o2], then this means that (x1, y1) ~ (x9, y9) are positions, o1 is the offset for the first loop and o2 is the offset for the second loop. ',
                                                                              'type': 'float'},
                                                           'pointsCount': {'doc': 'The number of 2D positions in pointsAndHoles ',
                                                                           'type': 'uint'},
                                                           'triangles': {'doc': 'Array of triangle indices into pointsAndHoles array. The size of this array is trianglesCount * 3 ',
                                                                         'type': 'short'},
                                                           'trianglesCount': {'doc': 'The number of triangles written in triangles array',
                                                                              'type': 'int'}},
                                               'args': [('pointsAndHoles',
                                                         'float',
                                                         'in'),
                                                        ('pointsCount',
                                                         'uint',
                                                         'in'),
                                                        ('outerPointsCount',
                                                         'uint',
                                                         'in'),
                                                        ('holesCount',
                                                         'uint',
                                                         'in'),
                                                        ('considerNormal',
                                                         'bool',
                                                         'in'),
                                                        ('normals',
                                                         'float',
                                                         'in'),
                                                        ('triangles',
                                                         'short',
                                                         'out'),
                                                        ('trianglesCount',
                                                         'int',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nTriangulates a polygon. The polygon consists of 2D positions with optional 3D normals and holes. These 2D positions can be in any coordinate system. 3D positions can be projected to a 2D plane by its face normal. 3D normals are references to help triangulation. This function can work without normals but normals can improve the quality. This function works with pointers and is more efficient than the other variant.',
                                               'inArgs': ['pointsAndHoles',
                                                          'pointsCount',
                                                          'outerPointsCount',
                                                          'holesCount',
                                                          'considerNormal',
                                                          'normals'],
                                               'outArgs': ['triangles',
                                                           'trianglesCount'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'considerNormal': [],
                                                                  'holesCount': ['unsigned'],
                                                                  'normals': ['const',
                                                                              '*'],
                                                                  'outerPointsCount': ['unsigned'],
                                                                  'pointsAndHoles': ['const',
                                                                                     '*'],
                                                                  'pointsCount': ['unsigned'],
                                                                  'triangles': ['unsigned',
                                                                                '*'],
                                                                  'trianglesCount': ['&']},
                                               'types': {'considerNormal': 'bool',
                                                         'holesCount': 'uint',
                                                         'normals': 'float',
                                                         'outerPointsCount': 'uint',
                                                         'pointsAndHoles': 'float',
                                                         'pointsCount': 'uint',
                                                         'triangles': 'short',
                                                         'trianglesCount': 'int'}},
                                              {'argInfo': {'holes': {'doc': "Array of offsets into the 'points' array indicating where each hole's vertices start. ",
                                                                     'type': 'MIntArray'},
                                                           'normals': {'doc': 'Array of normals. This array can be empty. If this array is not empty, then there must be one normal per point. ',
                                                                       'type': 'MFloatVectorArray'},
                                                           'outerPointsCount': {'doc': 'The number of outer (non-hole) positions in points array ',
                                                                                'type': 'uint'},
                                                           'points': {'doc': "Array of 3D points. The poly's outer vertices come first, followed by the vertices for each hole. ",
                                                                      'type': 'MFloatPointArray'},
                                                           'triangles': {'doc': 'Array of triangle indices into points array',
                                                                         'type': 'MIntArray'}},
                                               'args': [('points',
                                                         'MFloatPointArray',
                                                         'in'),
                                                        ('holes',
                                                         'MIntArray',
                                                         'in'),
                                                        ('outerPointsCount',
                                                         'uint',
                                                         'in'),
                                                        ('normals',
                                                         'MFloatVectorArray',
                                                         'in'),
                                                        ('triangles',
                                                         'MIntArray',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nTriangulates a polygon. The polygon consists of positions with optional normals and holes. Normals are references to help triangulation. This function can work without normals but normals can improve the quality. A simple example:',
                                               'inArgs': ['points',
                                                          'holes',
                                                          'outerPointsCount',
                                                          'normals'],
                                               'outArgs': ['triangles'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'holes': ['const',
                                                                            '&'],
                                                                  'normals': ['const',
                                                                              '&'],
                                                                  'outerPointsCount': ['unsigned'],
                                                                  'points': ['const',
                                                                             '&'],
                                                                  'triangles': ['&']},
                                               'types': {'holes': 'MIntArray',
                                                         'normals': 'MFloatVectorArray',
                                                         'outerPointsCount': 'uint',
                                                         'points': 'MFloatPointArray',
                                                         'triangles': 'MIntArray'}}],
                          'polygonVertexCount': [{'argInfo': {'polygonId': {'doc': 'The polygon index ',
                                                                            'type': 'int'}},
                                                  'args': [('polygonId',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the number of vertices for the specified polygon.',
                                                  'inArgs': ['polygonId'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The number of vertices for the specified polygon',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'polygonId': []},
                                                  'types': {'polygonId': 'int'}}],
                          'removeFaceColors': [{'argInfo': {'faceList': {'doc': 'The faces to remove color from',
                                                                         'type': 'MIntArray'}},
                                                'args': [('faceList',
                                                          'MIntArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRemove previously set color these faces. For each face, the color will be unset for each vertex-face component in the face.',
                                                'inArgs': ['faceList'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'faceList': ['&']},
                                                'types': {'faceList': 'MIntArray'}}],
                          'removeFaceVertexColors': [{'argInfo': {'faceList': {'doc': 'The faces to remove color for ',
                                                                               'type': 'MIntArray'},
                                                                  'vertexList': {'doc': 'The corresponding object-relative (mesh-relative/global) vertex indices to remove color for',
                                                                                 'type': 'MIntArray'}},
                                                      'args': [('faceList',
                                                                'MIntArray',
                                                                'in'),
                                                               ('vertexList',
                                                                'MIntArray',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nRemove colors for these face/vertex pairs',
                                                      'inArgs': ['faceList',
                                                                 'vertexList'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'faceList': ['&'],
                                                                         'vertexList': ['&']},
                                                      'types': {'faceList': 'MIntArray',
                                                                'vertexList': 'MIntArray'}}],
                          'removeVertexColors': [{'argInfo': {'vertexList': {'doc': 'The object-relative (mesh-relative/global) vertex indices to remove color from',
                                                                             'type': 'MIntArray'}},
                                                  'args': [('vertexList',
                                                            'MIntArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRemove color from these vertices.',
                                                  'inArgs': ['vertexList'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'vertexList': ['&']},
                                                  'types': {'vertexList': 'MIntArray'}}],
                          'renameUVSet': [{'argInfo': {'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                    'type': 'MDGModifier'},
                                                       'newName': {'doc': 'The name to set the uv set to. ',
                                                                   'type': 'MString'},
                                                       'origName': {'doc': 'The name of the uv set to change ',
                                                                    'type': 'MString'}},
                                           'args': [('origName',
                                                     'MString',
                                                     'in'),
                                                    ('newName',
                                                     'MString',
                                                     'in'),
                                                    ('modifier',
                                                     'MDGModifier',
                                                     'in')],
                                           'defaults': {'modifier': None},
                                           'deprecated': False,
                                           'doc': '\r\nRenames a uv set from one name to another for this mesh. The original name must exist, and the new name cannot be the same name as one that already exists. In these cases the uv set will not be renamed.',
                                           'inArgs': ['origName',
                                                      'newName',
                                                      'modifier'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'modifier': ['*'],
                                                              'newName': ['const',
                                                                          '&'],
                                                              'origName': ['const',
                                                                           '&']},
                                           'types': {'modifier': 'MDGModifier',
                                                     'newName': 'MString',
                                                     'origName': 'MString'}}],
                          'setBinaryBlindData': [{'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compID': {'doc': 'The component to set the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'int'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Attribute value as an MString. Note that the physical size must be set explicitly for binary data.',
                                                                       'type': 'MString'}},
                                                  'args': [('compID',
                                                            'int',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a value for a binary blind data attribute.',
                                                  'inArgs': ['compID',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getBinaryBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compID': [],
                                                                     'compType': [],
                                                                     'data': []},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compID': 'int',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MString'}},
                                                 {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Attribute value',
                                                                       'type': 'MString'}},
                                                  'args': [('compIDs',
                                                            'MIntArray',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a value for binary blind data on an array of components',
                                                  'inArgs': ['compIDs',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getBinaryBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': []},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MString'}},
                                                 {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'The attribute values for each component',
                                                                       'type': 'MStringArray'}},
                                                  'args': [('compIDs',
                                                            'MIntArray',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'MStringArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a values for a binary blind data on an array of components. The arrays of values and components must be the same size.',
                                                  'inArgs': ['compIDs',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getBinaryBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': ['&']},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MStringArray'}},
                                                 {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compID': {'doc': 'The component to set the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'int'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Attribute value as a char string ',
                                                                       'type': 'char'},
                                                              'length': {'doc': 'Length of char string to use',
                                                                         'type': 'int'}},
                                                  'args': [('compID',
                                                            'int',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'char',
                                                            'in'),
                                                           ('length',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a value for a binary blind data attribute.',
                                                  'inArgs': ['compID',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data',
                                                             'length'],
                                                  'inverse': ('getBinaryBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compID': [],
                                                                     'compType': [],
                                                                     'data': ['*'],
                                                                     'length': []},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compID': 'int',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'char',
                                                            'length': 'int'}}],
                          'setBoolBlindData': [{'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                         'type': 'MString'},
                                                            'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                            'type': 'int'},
                                                            'compID': {'doc': 'The component to set the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                       'type': 'int'},
                                                            'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                         'type': ('MFn',
                                                                                  'Type')},
                                                            'data': {'doc': 'Attribute value',
                                                                     'type': 'bool'}},
                                                'args': [('compID',
                                                          'int',
                                                          'in'),
                                                         ('compType',
                                                          ('MFn',
                                                           'Type'),
                                                          'in'),
                                                         ('blindDataId',
                                                          'int',
                                                          'in'),
                                                         ('attrName',
                                                          'MString',
                                                          'in'),
                                                         ('data',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet a value for a boolean blind data attribute.',
                                                'inArgs': ['compID',
                                                           'compType',
                                                           'blindDataId',
                                                           'attrName',
                                                           'data'],
                                                'inverse': ('getBoolBlindData',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attrName': [],
                                                                   'blindDataId': [],
                                                                   'compID': [],
                                                                   'compType': [],
                                                                   'data': []},
                                                'types': {'attrName': 'MString',
                                                          'blindDataId': 'int',
                                                          'compID': 'int',
                                                          'compType': ('MFn',
                                                                       'Type'),
                                                          'data': 'bool'}},
                                               {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                         'type': 'MString'},
                                                            'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                            'type': 'int'},
                                                            'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                        'type': 'MIntArray'},
                                                            'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                         'type': ('MFn',
                                                                                  'Type')},
                                                            'data': {'doc': 'Attribute value',
                                                                     'type': 'bool'}},
                                                'args': [('compIDs',
                                                          'MIntArray',
                                                          'in'),
                                                         ('compType',
                                                          ('MFn',
                                                           'Type'),
                                                          'in'),
                                                         ('blindDataId',
                                                          'int',
                                                          'in'),
                                                         ('attrName',
                                                          'MString',
                                                          'in'),
                                                         ('data',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet a value for boolean blind data on an array of components',
                                                'inArgs': ['compIDs',
                                                           'compType',
                                                           'blindDataId',
                                                           'attrName',
                                                           'data'],
                                                'inverse': ('getBoolBlindData',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attrName': [],
                                                                   'blindDataId': [],
                                                                   'compIDs': ['&'],
                                                                   'compType': [],
                                                                   'data': []},
                                                'types': {'attrName': 'MString',
                                                          'blindDataId': 'int',
                                                          'compIDs': 'MIntArray',
                                                          'compType': ('MFn',
                                                                       'Type'),
                                                          'data': 'bool'}},
                                               {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                         'type': 'MString'},
                                                            'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                            'type': 'int'},
                                                            'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                        'type': 'MIntArray'},
                                                            'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                         'type': ('MFn',
                                                                                  'Type')},
                                                            'data': {'doc': 'The attribute values for each component',
                                                                     'type': 'MIntArray'}},
                                                'args': [('compIDs',
                                                          'MIntArray',
                                                          'in'),
                                                         ('compType',
                                                          ('MFn',
                                                           'Type'),
                                                          'in'),
                                                         ('blindDataId',
                                                          'int',
                                                          'in'),
                                                         ('attrName',
                                                          'MString',
                                                          'in'),
                                                         ('data',
                                                          'MIntArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet a values for a boolean blind data on an array of components. The arrays of values and components must be the same size.',
                                                'inArgs': ['compIDs',
                                                           'compType',
                                                           'blindDataId',
                                                           'attrName',
                                                           'data'],
                                                'inverse': ('getBoolBlindData',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attrName': [],
                                                                   'blindDataId': [],
                                                                   'compIDs': ['&'],
                                                                   'compType': [],
                                                                   'data': ['&']},
                                                'types': {'attrName': 'MString',
                                                          'blindDataId': 'int',
                                                          'compIDs': 'MIntArray',
                                                          'compType': ('MFn',
                                                                       'Type'),
                                                          'data': 'MIntArray'}}],
                          'setCheckSamePointTwice': [{'argInfo': {'check': {'doc': 'true for checking, false otherwise ',
                                                                            'type': 'bool'}},
                                                      'args': [('check',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {'check': True},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method allows the turning on or off of duplicate point checking when polygons are created or added using this class. Checking for duplicates, is the default state.',
                                                      'inArgs': ['check'],
                                                      'inverse': ('getCheckSamePointTwice',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'check': []},
                                                      'types': {'check': 'bool'}}],
                          'setColor': [{'argInfo': {'color': {'doc': 'The new color value that is to be set ',
                                                              'type': 'MColor'},
                                                    'colorId': {'doc': 'The element in the color list to be set ',
                                                                'type': 'int'},
                                                    'colorSet': {'doc': 'Color set to work with',
                                                                 'type': 'MString'}},
                                        'args': [('colorId',
                                                  'int',
                                                  'in'),
                                                 ('color',
                                                  'MColor',
                                                  'in'),
                                                 ('colorSet',
                                                  'MString',
                                                  'in')],
                                        'defaults': {'colorSet': None},
                                        'deprecated': False,
                                        'doc': '\r\nSets the specified color values. The colorId is the element in the color list that will be set. If the colorId is greater than or equal to  numColors()  then the color list will be grown to accommodate the specified color.',
                                        'inArgs': ['colorId',
                                                   'color',
                                                   'colorSet'],
                                        'inverse': ('getColor', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'color': ['const',
                                                                     '&'],
                                                           'colorId': [],
                                                           'colorSet': ['const',
                                                                        '*']},
                                        'types': {'color': 'MColor',
                                                  'colorId': 'int',
                                                  'colorSet': 'MString'}},
                                       {'argInfo': {'color': {'doc': 'The new color value that is to be set ',
                                                              'type': 'MColor'},
                                                    'colorId': {'doc': 'The element in the color list to be set ',
                                                                'type': 'int'},
                                                    'colorSet': {'doc': 'Color set to work with ',
                                                                 'type': 'MString'},
                                                    'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                            'type': ('MFnMesh',
                                                                     'MColorRepresentation')}},
                                        'args': [('colorId',
                                                  'int',
                                                  'in'),
                                                 ('color',
                                                  'MColor',
                                                  'in'),
                                                 ('colorSet',
                                                  'MString',
                                                  'in'),
                                                 ('rep',
                                                  ('MFnMesh',
                                                   'MColorRepresentation'),
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the specified color values of specified channels. The colorId is the element in the color list that will be set. If the colorId is greater than or equal to  numColors()  then the color list will be grown to accommodate the specified color.',
                                        'inArgs': ['colorId',
                                                   'color',
                                                   'colorSet',
                                                   'rep'],
                                        'inverse': ('getColor', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'color': ['const',
                                                                     '&'],
                                                           'colorId': [],
                                                           'colorSet': ['const',
                                                                        '*'],
                                                           'rep': []},
                                        'types': {'color': 'MColor',
                                                  'colorId': 'int',
                                                  'colorSet': 'MString',
                                                  'rep': ('MFnMesh',
                                                          'MColorRepresentation')}}],
                          'setColors': [{'argInfo': {'colorArray': {'doc': 'The array of color values to be set ',
                                                                    'type': 'MColorArray'},
                                                     'colorSet': {'doc': 'The color set to work with',
                                                                  'type': 'MString'}},
                                         'args': [('colorArray',
                                                   'MColorArray',
                                                   'in'),
                                                  ('colorSet',
                                                   'MString',
                                                   'in')],
                                         'defaults': {'colorSet': None},
                                         'deprecated': False,
                                         'doc': '\r\nSets all of the colors for this mesh. The color array must be at least as large as the current color set size. You can determine the color set size by calling  numColors()  for the default color set, or numColors(colorSet) for a named color set.',
                                         'inArgs': ['colorArray',
                                                    'colorSet'],
                                         'inverse': ('getColors', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'colorArray': ['const',
                                                                           '&'],
                                                            'colorSet': ['const',
                                                                         '*']},
                                         'types': {'colorArray': 'MColorArray',
                                                   'colorSet': 'MString'}},
                                        {'argInfo': {'colorArray': {'doc': 'The array of color values to be set ',
                                                                    'type': 'MColorArray'},
                                                     'colorSet': {'doc': 'The color set to work with ',
                                                                  'type': 'MString'},
                                                     'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                             'type': ('MFnMesh',
                                                                      'MColorRepresentation')}},
                                         'args': [('colorArray',
                                                   'MColorArray',
                                                   'in'),
                                                  ('colorSet',
                                                   'MString',
                                                   'in'),
                                                  ('rep',
                                                   ('MFnMesh',
                                                    'MColorRepresentation'),
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSets all of the colors of specified channels for this mesh. The color array must be at least as large as the current color set size. You can determine the color set size by calling  numColors()  for the default color set, or numColors(colorSet) for a named color set.',
                                         'inArgs': ['colorArray',
                                                    'colorSet',
                                                    'rep'],
                                         'inverse': ('getColors', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'colorArray': ['const',
                                                                           '&'],
                                                            'colorSet': ['const',
                                                                         '*'],
                                                            'rep': []},
                                         'types': {'colorArray': 'MColorArray',
                                                   'colorSet': 'MString',
                                                   'rep': ('MFnMesh',
                                                           'MColorRepresentation')}}],
                          'setCreaseEdges': [{'argInfo': {'creaseData': {'doc': 'The data related to the crease edges.',
                                                                         'type': 'MDoubleArray'},
                                                          'edgeIds': {'doc': 'The list of crease edges ids. ',
                                                                      'type': 'MUintArray'}},
                                              'args': [('edgeIds',
                                                        'MUintArray',
                                                        'in'),
                                                       ('creaseData',
                                                        'MDoubleArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method sets the specified edges of the mesh as crease edges.',
                                              'inArgs': ['edgeIds',
                                                         'creaseData'],
                                              'inverse': ('getCreaseEdges',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'creaseData': ['const',
                                                                                '&'],
                                                                 'edgeIds': ['const',
                                                                             '&']},
                                              'types': {'creaseData': 'MDoubleArray',
                                                        'edgeIds': 'MUintArray'}}],
                          'setCreaseVertices': [{'argInfo': {'creaseData': {'doc': 'The data related to the crease vertices.',
                                                                            'type': 'MDoubleArray'},
                                                             'vertexIds': {'doc': 'The list of crease vertices ids. ',
                                                                           'type': 'MUintArray'}},
                                                 'args': [('vertexIds',
                                                           'MUintArray',
                                                           'in'),
                                                          ('creaseData',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method sets the specified vertices of the mesh as crease vertices.',
                                                 'inArgs': ['vertexIds',
                                                            'creaseData'],
                                                 'inverse': ('getCreaseVertices',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'creaseData': ['const',
                                                                                   '&'],
                                                                    'vertexIds': ['const',
                                                                                  '&']},
                                                 'types': {'creaseData': 'MDoubleArray',
                                                           'vertexIds': 'MUintArray'}}],
                          'setCurrentColorSetName': [{'argInfo': {'currentSelection': {'doc': 'Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.',
                                                                                       'type': 'MSelectionList'},
                                                                  'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                               'type': 'MDGModifier'},
                                                                  'setName': {'doc': 'Name of color set to make "current" ',
                                                                              'type': 'MString'}},
                                                      'args': [('setName',
                                                                'MString',
                                                                'in'),
                                                               ('modifier',
                                                                'MDGModifier',
                                                                'in'),
                                                               ('currentSelection',
                                                                'MSelectionList',
                                                                'in')],
                                                      'defaults': {'currentSelection': None,
                                                                   'modifier': None},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the "current" or "working" color set for this object. The "current" color set is the set to use by functions that do not have a specific color set defined.',
                                                      'inArgs': ['setName',
                                                                 'modifier',
                                                                 'currentSelection'],
                                                      'inverse': ('currentColorSetName',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'currentSelection': ['*'],
                                                                         'modifier': ['*'],
                                                                         'setName': ['const',
                                                                                     '&']},
                                                      'types': {'currentSelection': 'MSelectionList',
                                                                'modifier': 'MDGModifier',
                                                                'setName': 'MString'}}],
                          'setCurrentUVSetName': [{'argInfo': {'currentSelection': {'doc': 'Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.',
                                                                                    'type': 'MSelectionList'},
                                                               'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                            'type': 'MDGModifier'},
                                                               'setName': {'doc': 'Name of uv set to make "current" ',
                                                                           'type': 'MString'}},
                                                   'args': [('setName',
                                                             'MString',
                                                             'in'),
                                                            ('modifier',
                                                             'MDGModifier',
                                                             'in'),
                                                            ('currentSelection',
                                                             'MSelectionList',
                                                             'in')],
                                                   'defaults': {'currentSelection': None,
                                                                'modifier': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the "current" uv set for this object. The "current" uv set is the uv set to use when no uv set name is specified for a uv set operation. If the uv set does not exist then the "current" uv set will not be changed.',
                                                   'inArgs': ['setName',
                                                              'modifier',
                                                              'currentSelection'],
                                                   'inverse': ('currentUVSetName',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'currentSelection': ['*'],
                                                                      'modifier': ['*'],
                                                                      'setName': ['const',
                                                                                  '&']},
                                                   'types': {'currentSelection': 'MSelectionList',
                                                             'modifier': 'MDGModifier',
                                                             'setName': 'MString'}}],
                          'setDisplayColors': [{'argInfo': {'enable': {'doc': 'True to turn on color display, false to turn it off.',
                                                                       'type': 'bool'}},
                                                'args': [('enable',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet whether the mesh node should display vertex colors.',
                                                'inArgs': ['enable'],
                                                'inverse': ('displayColors',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'enable': []},
                                                'types': {'enable': 'bool'}}],
                          'setDoubleBlindData': [{'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compID': {'doc': 'The component to set the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'int'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Attribute value',
                                                                       'type': 'double'}},
                                                  'args': [('compID',
                                                            'int',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a value for a double blind data attribute.',
                                                  'inArgs': ['compID',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getDoubleBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compID': [],
                                                                     'compType': [],
                                                                     'data': []},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compID': 'int',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'double'}},
                                                 {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Attribute value',
                                                                       'type': 'double'}},
                                                  'args': [('compIDs',
                                                            'MIntArray',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a value for double blind data on an array of components',
                                                  'inArgs': ['compIDs',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getDoubleBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': []},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'double'}},
                                                 {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'The attribute values for each component',
                                                                       'type': 'MDoubleArray'}},
                                                  'args': [('compIDs',
                                                            'MIntArray',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'MDoubleArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a values for a double blind data on an array of components. The arrays of values and components must be the same size.',
                                                  'inArgs': ['compIDs',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getDoubleBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': ['&']},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MDoubleArray'}}],
                          'setEdgeSmoothing': [{'argInfo': {'edgeId': {'doc': 'The edge to set the smoothing information for ',
                                                                       'type': 'int'},
                                                            'smooth': {'doc': 'If true the edge will be smooth (soft), otherwise the edge will be hard.',
                                                                       'type': 'bool'}},
                                                'args': [('edgeId',
                                                          'int',
                                                          'in'),
                                                         ('smooth',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'smooth': True},
                                                'deprecated': False,
                                                'doc': '\r\nThis method sets the specified edge to be hard or smooth (soft). You must use the  cleanupEdgeSmoothing  method after all the desired edges on your mesh have had setEdgeSmoothing done. Use the  updateSurface  method to indicate the mesh needs to be redrawn.',
                                                'inArgs': ['edgeId',
                                                           'smooth'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'edgeId': [],
                                                                   'smooth': []},
                                                'types': {'edgeId': 'int',
                                                          'smooth': 'bool'}}],
                          'setEdgeSmoothings': [{'argInfo': {'edgeIds': {'doc': 'The edges to set the smoothing information for ',
                                                                         'type': 'MIntArray'},
                                                             'smooths': {'doc': 'If true the edges will be smooth (soft), otherwise the edges will be hard.',
                                                                         'type': 'MIntArray'}},
                                                 'args': [('edgeIds',
                                                           'MIntArray',
                                                           'in'),
                                                          ('smooths',
                                                           'MIntArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method sets the specified edges to be hard or smooth (soft). You must use the  cleanupEdgeSmoothing  method after all the desired edges on your mesh have had setEdgeSmoothing done. Use the  updateSurface  method to indicate the mesh needs to be redrawn.',
                                                 'inArgs': ['edgeIds',
                                                            'smooths'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'edgeIds': ['const',
                                                                                '&'],
                                                                    'smooths': ['const',
                                                                                '&']},
                                                 'types': {'edgeIds': 'MIntArray',
                                                           'smooths': 'MIntArray'}}],
                          'setFaceColor': [{'argInfo': {'color': {'doc': 'The color to set ',
                                                                  'type': 'MColor'},
                                                        'faceIndex': {'doc': 'The face to set it for',
                                                                      'type': 'int'}},
                                            'args': [('color',
                                                      'MColor',
                                                      'in'),
                                                     ('faceIndex',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet vertex-face Color for all vertices on this face.',
                                            'inArgs': ['color',
                                                       'faceIndex'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'color': ['&'],
                                                               'faceIndex': []},
                                            'types': {'color': 'MColor',
                                                      'faceIndex': 'int'}},
                                           {'argInfo': {'color': {'doc': 'The color to set ',
                                                                  'type': 'MColor'},
                                                        'faceIndex': {'doc': 'The face to set it for ',
                                                                      'type': 'int'},
                                                        'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                'type': ('MFnMesh',
                                                                         'MColorRepresentation')}},
                                            'args': [('color',
                                                      'MColor',
                                                      'in'),
                                                     ('faceIndex',
                                                      'int',
                                                      'in'),
                                                     ('rep',
                                                      ('MFnMesh',
                                                       'MColorRepresentation'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet vertex-face Color of specified channels for all vertices on this face.',
                                            'inArgs': ['color',
                                                       'faceIndex',
                                                       'rep'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'color': ['&'],
                                                               'faceIndex': [],
                                                               'rep': []},
                                            'types': {'color': 'MColor',
                                                      'faceIndex': 'int',
                                                      'rep': ('MFnMesh',
                                                              'MColorRepresentation')}}],
                          'setFaceColors': [{'argInfo': {'colors': {'doc': 'The colors to set ',
                                                                    'type': 'MColorArray'},
                                                         'faceList': {'doc': 'The faces to set it for',
                                                                      'type': 'MIntArray'}},
                                             'args': [('colors',
                                                       'MColorArray',
                                                       'in'),
                                                      ('faceList',
                                                       'MIntArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet color for these faces. The color will be set for each vertex-face component of a face.',
                                             'inArgs': ['colors',
                                                        'faceList'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'colors': ['&'],
                                                                'faceList': ['&']},
                                             'types': {'colors': 'MColorArray',
                                                       'faceList': 'MIntArray'}},
                                            {'argInfo': {'colors': {'doc': 'The colors to set ',
                                                                    'type': 'MColorArray'},
                                                         'faceList': {'doc': 'The faces to set it for ',
                                                                      'type': 'MIntArray'},
                                                         'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                 'type': ('MFnMesh',
                                                                          'MColorRepresentation')}},
                                             'args': [('colors',
                                                       'MColorArray',
                                                       'in'),
                                                      ('faceList',
                                                       'MIntArray',
                                                       'in'),
                                                      ('rep',
                                                       ('MFnMesh',
                                                        'MColorRepresentation'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet color of specified channels for these faces. The color will be set for each vertex-face component of a face.',
                                             'inArgs': ['colors',
                                                        'faceList',
                                                        'rep'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'colors': ['&'],
                                                                'faceList': ['&'],
                                                                'rep': []},
                                             'types': {'colors': 'MColorArray',
                                                       'faceList': 'MIntArray',
                                                       'rep': ('MFnMesh',
                                                               'MColorRepresentation')}}],
                          'setFaceVertexColor': [{'argInfo': {'color': {'doc': 'The color to set ',
                                                                        'type': 'MColor'},
                                                              'faceIndex': {'doc': 'The face to set it for ',
                                                                            'type': 'int'},
                                                              'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                           'type': 'MDGModifier'},
                                                              'vertexIndex': {'doc': 'The object-relative (mesh_relative/global) vertex index to set it for ',
                                                                              'type': 'int'}},
                                                  'args': [('color',
                                                            'MColor',
                                                            'in'),
                                                           ('faceIndex',
                                                            'int',
                                                            'in'),
                                                           ('vertexIndex',
                                                            'int',
                                                            'in'),
                                                           ('modifier',
                                                            'MDGModifier',
                                                            'in')],
                                                  'defaults': {'modifier': None},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet color for this vertex in this face.',
                                                  'inArgs': ['color',
                                                             'faceIndex',
                                                             'vertexIndex',
                                                             'modifier'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['&'],
                                                                     'faceIndex': [],
                                                                     'modifier': ['*'],
                                                                     'vertexIndex': []},
                                                  'types': {'color': 'MColor',
                                                            'faceIndex': 'int',
                                                            'modifier': 'MDGModifier',
                                                            'vertexIndex': 'int'}},
                                                 {'argInfo': {'color': {'doc': 'The color to set ',
                                                                        'type': 'MColor'},
                                                              'faceIndex': {'doc': 'The face to set it for ',
                                                                            'type': 'int'},
                                                              'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                           'type': 'MDGModifier'},
                                                              'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                      'type': ('MFnMesh',
                                                                               'MColorRepresentation')},
                                                              'vertexIndex': {'doc': 'The object-relative (mesh_relative/global) vertex index to set it for ',
                                                                              'type': 'int'}},
                                                  'args': [('color',
                                                            'MColor',
                                                            'in'),
                                                           ('faceIndex',
                                                            'int',
                                                            'in'),
                                                           ('vertexIndex',
                                                            'int',
                                                            'in'),
                                                           ('modifier',
                                                            'MDGModifier',
                                                            'in'),
                                                           ('rep',
                                                            ('MFnMesh',
                                                             'MColorRepresentation'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet color of specified channels for this vertex in this face.',
                                                  'inArgs': ['color',
                                                             'faceIndex',
                                                             'vertexIndex',
                                                             'modifier',
                                                             'rep'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['&'],
                                                                     'faceIndex': [],
                                                                     'modifier': ['*'],
                                                                     'rep': [],
                                                                     'vertexIndex': []},
                                                  'types': {'color': 'MColor',
                                                            'faceIndex': 'int',
                                                            'modifier': 'MDGModifier',
                                                            'rep': ('MFnMesh',
                                                                    'MColorRepresentation'),
                                                            'vertexIndex': 'int'}},
                                                 {'argInfo': {'color': {'doc': 'The color to set ',
                                                                        'type': 'MColor'},
                                                              'faceIndex': {'doc': 'The face to set it for ',
                                                                            'type': 'int'},
                                                              'localVertexIndex': {'doc': 'The face-relative (local) vertex index to set it for ',
                                                                                   'type': 'int'},
                                                              'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                           'type': 'MDGModifier'}},
                                                  'args': [('faceIndex',
                                                            'int',
                                                            'in'),
                                                           ('localVertexIndex',
                                                            'int',
                                                            'in'),
                                                           ('color',
                                                            'MColor',
                                                            'in'),
                                                           ('modifier',
                                                            'MDGModifier',
                                                            'in')],
                                                  'defaults': {'modifier': None},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet color for this vertex in this face.',
                                                  'inArgs': ['faceIndex',
                                                             'localVertexIndex',
                                                             'color',
                                                             'modifier'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['&'],
                                                                     'faceIndex': [],
                                                                     'localVertexIndex': [],
                                                                     'modifier': ['*']},
                                                  'types': {'color': 'MColor',
                                                            'faceIndex': 'int',
                                                            'localVertexIndex': 'int',
                                                            'modifier': 'MDGModifier'}},
                                                 {'argInfo': {'color': {'doc': 'The color to set ',
                                                                        'type': 'MColor'},
                                                              'faceIndex': {'doc': 'The face to set it for ',
                                                                            'type': 'int'},
                                                              'localVertexIndex': {'doc': 'The face-relative (local) vertex index to set it for ',
                                                                                   'type': 'int'},
                                                              'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                           'type': 'MDGModifier'},
                                                              'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                      'type': ('MFnMesh',
                                                                               'MColorRepresentation')}},
                                                  'args': [('faceIndex',
                                                            'int',
                                                            'in'),
                                                           ('localVertexIndex',
                                                            'int',
                                                            'in'),
                                                           ('color',
                                                            'MColor',
                                                            'in'),
                                                           ('modifier',
                                                            'MDGModifier',
                                                            'in'),
                                                           ('rep',
                                                            ('MFnMesh',
                                                             'MColorRepresentation'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet color of specified channels for this vertex in this face.',
                                                  'inArgs': ['faceIndex',
                                                             'localVertexIndex',
                                                             'color',
                                                             'modifier',
                                                             'rep'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['&'],
                                                                     'faceIndex': [],
                                                                     'localVertexIndex': [],
                                                                     'modifier': ['*'],
                                                                     'rep': []},
                                                  'types': {'color': 'MColor',
                                                            'faceIndex': 'int',
                                                            'localVertexIndex': 'int',
                                                            'modifier': 'MDGModifier',
                                                            'rep': ('MFnMesh',
                                                                    'MColorRepresentation')}}],
                          'setFaceVertexColors': [{'argInfo': {'colors': {'doc': 'The colors to set ',
                                                                          'type': 'MColorArray'},
                                                               'faceList': {'doc': 'The faces to set it for ',
                                                                            'type': 'MIntArray'},
                                                               'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                            'type': 'MDGModifier'},
                                                               'vertexList': {'doc': 'The object-relative (mesh-relative/global) vertex indices to set it for ',
                                                                              'type': 'MIntArray'}},
                                                   'args': [('colors',
                                                             'MColorArray',
                                                             'in'),
                                                            ('faceList',
                                                             'MIntArray',
                                                             'in'),
                                                            ('vertexList',
                                                             'MIntArray',
                                                             'in'),
                                                            ('modifier',
                                                             'MDGModifier',
                                                             'in')],
                                                   'defaults': {'modifier': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet colors for these face/vertex pairs.',
                                                   'inArgs': ['colors',
                                                              'faceList',
                                                              'vertexList',
                                                              'modifier'],
                                                   'inverse': ('getFaceVertexColors',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'colors': ['&'],
                                                                      'faceList': ['&'],
                                                                      'modifier': ['*'],
                                                                      'vertexList': ['&']},
                                                   'types': {'colors': 'MColorArray',
                                                             'faceList': 'MIntArray',
                                                             'modifier': 'MDGModifier',
                                                             'vertexList': 'MIntArray'}},
                                                  {'argInfo': {'colors': {'doc': 'The colors to set ',
                                                                          'type': 'MColorArray'},
                                                               'faceList': {'doc': 'The faces to set it for ',
                                                                            'type': 'MIntArray'},
                                                               'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                            'type': 'MDGModifier'},
                                                               'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                       'type': ('MFnMesh',
                                                                                'MColorRepresentation')},
                                                               'vertexList': {'doc': 'The object-relative (mesh-relative/global) vertex indices to set it for ',
                                                                              'type': 'MIntArray'}},
                                                   'args': [('colors',
                                                             'MColorArray',
                                                             'in'),
                                                            ('faceList',
                                                             'MIntArray',
                                                             'in'),
                                                            ('vertexList',
                                                             'MIntArray',
                                                             'in'),
                                                            ('modifier',
                                                             'MDGModifier',
                                                             'in'),
                                                            ('rep',
                                                             ('MFnMesh',
                                                              'MColorRepresentation'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet colors of specified channels for these face/vertex pairs.',
                                                   'inArgs': ['colors',
                                                              'faceList',
                                                              'vertexList',
                                                              'modifier',
                                                              'rep'],
                                                   'inverse': ('getFaceVertexColors',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'colors': ['&'],
                                                                      'faceList': ['&'],
                                                                      'modifier': ['*'],
                                                                      'rep': [],
                                                                      'vertexList': ['&']},
                                                   'types': {'colors': 'MColorArray',
                                                             'faceList': 'MIntArray',
                                                             'modifier': 'MDGModifier',
                                                             'rep': ('MFnMesh',
                                                                     'MColorRepresentation'),
                                                             'vertexList': 'MIntArray'}}],
                          'setFaceVertexNormal': [{'argInfo': {'faceId': {'doc': 'The face to set it for ',
                                                                          'type': 'int'},
                                                               'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                            'type': 'MDGModifier'},
                                                               'normalIn': {'doc': 'The normal to set ',
                                                                            'type': 'MVector'},
                                                               'space': {'doc': 'World space or Object space ',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'vertexId': {'doc': 'The object-relative (mesh-relative/global) vertex index to set it for ',
                                                                            'type': 'int'}},
                                                   'args': [('normalIn',
                                                             'MVector',
                                                             'in'),
                                                            ('faceId',
                                                             'int',
                                                             'in'),
                                                            ('vertexId',
                                                             'int',
                                                             'in'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in'),
                                                            ('modifier',
                                                             'MDGModifier',
                                                             'in')],
                                                   'defaults': {'modifier': None,
                                                                'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject')},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet Normal for this face/vertex pair',
                                                   'inArgs': ['normalIn',
                                                              'faceId',
                                                              'vertexId',
                                                              'space',
                                                              'modifier'],
                                                   'inverse': None,
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'faceId': [],
                                                                      'modifier': ['*'],
                                                                      'normalIn': ['&'],
                                                                      'space': [],
                                                                      'vertexId': []},
                                                   'types': {'faceId': 'int',
                                                             'modifier': 'MDGModifier',
                                                             'normalIn': 'MVector',
                                                             'space': ('MSpace',
                                                                       'Space'),
                                                             'vertexId': 'int'}}],
                          'setFaceVertexNormals': [{'argInfo': {'faceList': {'doc': 'The faces to set them for ',
                                                                             'type': 'MIntArray'},
                                                                'normalsIn': {'doc': 'The normals to set ',
                                                                              'type': 'MVectorArray'},
                                                                'space': {'doc': 'World space or Object space',
                                                                          'type': ('MSpace',
                                                                                   'Space')},
                                                                'vertexList': {'doc': 'The object-relative (mesh-relative/global) vertex indices to set them for ',
                                                                               'type': 'MIntArray'}},
                                                    'args': [('normalsIn',
                                                              'MVectorArray',
                                                              'in'),
                                                             ('faceList',
                                                              'MIntArray',
                                                              'in'),
                                                             ('vertexList',
                                                              'MIntArray',
                                                              'in'),
                                                             ('space',
                                                              ('MSpace',
                                                               'Space'),
                                                              'in')],
                                                    'defaults': {'space': ('MSpace',
                                                                           'Space',
                                                                           'kObject')},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet Normals for the given face/vertex pairs. Note that if there is a vertex-face mismatch anywhere in the list, this method will return an error, and not set any of the normals.',
                                                    'inArgs': ['normalsIn',
                                                               'faceList',
                                                               'vertexList',
                                                               'space'],
                                                    'inverse': None,
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'faceList': ['&'],
                                                                       'normalsIn': ['&'],
                                                                       'space': [],
                                                                       'vertexList': ['&']},
                                                    'types': {'faceList': 'MIntArray',
                                                              'normalsIn': 'MVectorArray',
                                                              'space': ('MSpace',
                                                                        'Space'),
                                                              'vertexList': 'MIntArray'}}],
                          'setFloatBlindData': [{'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                          'type': 'MString'},
                                                             'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                             'type': 'int'},
                                                             'compID': {'doc': 'The component to set the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                        'type': 'int'},
                                                             'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                          'type': ('MFn',
                                                                                   'Type')},
                                                             'data': {'doc': 'Attribute value',
                                                                      'type': 'float'}},
                                                 'args': [('compID',
                                                           'int',
                                                           'in'),
                                                          ('compType',
                                                           ('MFn',
                                                            'Type'),
                                                           'in'),
                                                          ('blindDataId',
                                                           'int',
                                                           'in'),
                                                          ('attrName',
                                                           'MString',
                                                           'in'),
                                                          ('data',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet a value for a float blind data attribute.',
                                                 'inArgs': ['compID',
                                                            'compType',
                                                            'blindDataId',
                                                            'attrName',
                                                            'data'],
                                                 'inverse': ('getFloatBlindData',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'attrName': [],
                                                                    'blindDataId': [],
                                                                    'compID': [],
                                                                    'compType': [],
                                                                    'data': []},
                                                 'types': {'attrName': 'MString',
                                                           'blindDataId': 'int',
                                                           'compID': 'int',
                                                           'compType': ('MFn',
                                                                        'Type'),
                                                           'data': 'float'}},
                                                {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                          'type': 'MString'},
                                                             'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                             'type': 'int'},
                                                             'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'MIntArray'},
                                                             'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                          'type': ('MFn',
                                                                                   'Type')},
                                                             'data': {'doc': 'Attribute value',
                                                                      'type': 'float'}},
                                                 'args': [('compIDs',
                                                           'MIntArray',
                                                           'in'),
                                                          ('compType',
                                                           ('MFn',
                                                            'Type'),
                                                           'in'),
                                                          ('blindDataId',
                                                           'int',
                                                           'in'),
                                                          ('attrName',
                                                           'MString',
                                                           'in'),
                                                          ('data',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet a value for float blind data on an array of components',
                                                 'inArgs': ['compIDs',
                                                            'compType',
                                                            'blindDataId',
                                                            'attrName',
                                                            'data'],
                                                 'inverse': ('getFloatBlindData',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'attrName': [],
                                                                    'blindDataId': [],
                                                                    'compIDs': ['&'],
                                                                    'compType': [],
                                                                    'data': []},
                                                 'types': {'attrName': 'MString',
                                                           'blindDataId': 'int',
                                                           'compIDs': 'MIntArray',
                                                           'compType': ('MFn',
                                                                        'Type'),
                                                           'data': 'float'}},
                                                {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                          'type': 'MString'},
                                                             'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                             'type': 'int'},
                                                             'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'MIntArray'},
                                                             'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                          'type': ('MFn',
                                                                                   'Type')},
                                                             'data': {'doc': 'The attribute values for each component',
                                                                      'type': 'MFloatArray'}},
                                                 'args': [('compIDs',
                                                           'MIntArray',
                                                           'in'),
                                                          ('compType',
                                                           ('MFn',
                                                            'Type'),
                                                           'in'),
                                                          ('blindDataId',
                                                           'int',
                                                           'in'),
                                                          ('attrName',
                                                           'MString',
                                                           'in'),
                                                          ('data',
                                                           'MFloatArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet a values for a float blind data on an array of components. The arrays of values and components must be the same size.',
                                                 'inArgs': ['compIDs',
                                                            'compType',
                                                            'blindDataId',
                                                            'attrName',
                                                            'data'],
                                                 'inverse': ('getFloatBlindData',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'attrName': [],
                                                                    'blindDataId': [],
                                                                    'compIDs': ['&'],
                                                                    'compType': [],
                                                                    'data': ['&']},
                                                 'types': {'attrName': 'MString',
                                                           'blindDataId': 'int',
                                                           'compIDs': 'MIntArray',
                                                           'compType': ('MFn',
                                                                        'Type'),
                                                           'data': 'MFloatArray'}}],
                          'setIntBlindData': [{'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                        'type': 'MString'},
                                                           'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                           'type': 'int'},
                                                           'compID': {'doc': 'The component to set the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                      'type': 'int'},
                                                           'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                        'type': ('MFn',
                                                                                 'Type')},
                                                           'data': {'doc': 'Attribute value',
                                                                    'type': 'int'}},
                                               'args': [('compID',
                                                         'int',
                                                         'in'),
                                                        ('compType',
                                                         ('MFn',
                                                          'Type'),
                                                         'in'),
                                                        ('blindDataId',
                                                         'int',
                                                         'in'),
                                                        ('attrName',
                                                         'MString',
                                                         'in'),
                                                        ('data',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet a value for an integer blind data attribute.',
                                               'inArgs': ['compID',
                                                          'compType',
                                                          'blindDataId',
                                                          'attrName',
                                                          'data'],
                                               'inverse': ('getIntBlindData',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'attrName': [],
                                                                  'blindDataId': [],
                                                                  'compID': [],
                                                                  'compType': [],
                                                                  'data': []},
                                               'types': {'attrName': 'MString',
                                                         'blindDataId': 'int',
                                                         'compID': 'int',
                                                         'compType': ('MFn',
                                                                      'Type'),
                                                         'data': 'int'}},
                                              {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                        'type': 'MString'},
                                                           'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                           'type': 'int'},
                                                           'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                       'type': 'MIntArray'},
                                                           'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                        'type': ('MFn',
                                                                                 'Type')},
                                                           'data': {'doc': 'Attribute value',
                                                                    'type': 'int'}},
                                               'args': [('compIDs',
                                                         'MIntArray',
                                                         'in'),
                                                        ('compType',
                                                         ('MFn',
                                                          'Type'),
                                                         'in'),
                                                        ('blindDataId',
                                                         'int',
                                                         'in'),
                                                        ('attrName',
                                                         'MString',
                                                         'in'),
                                                        ('data',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet a value for an integer blind data on an array of components',
                                               'inArgs': ['compIDs',
                                                          'compType',
                                                          'blindDataId',
                                                          'attrName',
                                                          'data'],
                                               'inverse': ('getIntBlindData',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'attrName': [],
                                                                  'blindDataId': [],
                                                                  'compIDs': ['&'],
                                                                  'compType': [],
                                                                  'data': []},
                                               'types': {'attrName': 'MString',
                                                         'blindDataId': 'int',
                                                         'compIDs': 'MIntArray',
                                                         'compType': ('MFn',
                                                                      'Type'),
                                                         'data': 'int'}},
                                              {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                        'type': 'MString'},
                                                           'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                           'type': 'int'},
                                                           'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                       'type': 'MIntArray'},
                                                           'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                        'type': ('MFn',
                                                                                 'Type')},
                                                           'data': {'doc': 'The attribute values for each component',
                                                                    'type': 'MIntArray'}},
                                               'args': [('compIDs',
                                                         'MIntArray',
                                                         'in'),
                                                        ('compType',
                                                         ('MFn',
                                                          'Type'),
                                                         'in'),
                                                        ('blindDataId',
                                                         'int',
                                                         'in'),
                                                        ('attrName',
                                                         'MString',
                                                         'in'),
                                                        ('data',
                                                         'MIntArray',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet a values for an integer blind data on an array of components. The arrays of values and components must be the same size.',
                                               'inArgs': ['compIDs',
                                                          'compType',
                                                          'blindDataId',
                                                          'attrName',
                                                          'data'],
                                               'inverse': ('getIntBlindData',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'attrName': [],
                                                                  'blindDataId': [],
                                                                  'compIDs': ['&'],
                                                                  'compType': [],
                                                                  'data': ['&']},
                                               'types': {'attrName': 'MString',
                                                         'blindDataId': 'int',
                                                         'compIDs': 'MIntArray',
                                                         'compType': ('MFn',
                                                                      'Type'),
                                                         'data': 'MIntArray'}}],
                          'setInvisibleFaces': [{'argInfo': {'faceIds': {'doc': 'The list of face ids to be made visible/invisible. ',
                                                                         'type': 'MUintArray'},
                                                             'makeVisible': {'doc': 'If true the faces will be made visible. The default is false, which will make them invisible.',
                                                                             'type': 'bool'}},
                                                 'args': [('faceIds',
                                                           'MUintArray',
                                                           'in'),
                                                          ('makeVisible',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {'makeVisible': False},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method sets the specified faces of the mesh to be visible or invisible. See the  getInvisibleFaces()  method for a description of invisible faces.',
                                                 'inArgs': ['faceIds',
                                                            'makeVisible'],
                                                 'inverse': ('getInvisibleFaces',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'faceIds': ['const',
                                                                                '&'],
                                                                    'makeVisible': []},
                                                 'types': {'faceIds': 'MUintArray',
                                                           'makeVisible': 'bool'}}],
                          'setIsColorClamped': [{'argInfo': {'clamped': {'doc': 'If the color set should be set clamped',
                                                                         'type': 'bool'},
                                                             'colorSet': {'doc': 'Color set to work with ',
                                                                          'type': 'MString'}},
                                                 'args': [('colorSet',
                                                           'MString',
                                                           'in'),
                                                          ('clamped',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet the color set to be clamped.',
                                                 'inArgs': ['colorSet',
                                                            'clamped'],
                                                 'inverse': ('isColorClamped',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'clamped': [],
                                                                    'colorSet': ['const',
                                                                                 '&']},
                                                 'types': {'clamped': 'bool',
                                                           'colorSet': 'MString'}}],
                          'setNormals': [{'argInfo': {'normals': {'doc': 'The normal array to set ',
                                                                  'type': 'MFloatVectorArray'},
                                                      'space': {'doc': 'World space or Object space',
                                                                'type': ('MSpace',
                                                                         'Space')}},
                                          'args': [('normals',
                                                    'MFloatVectorArray',
                                                    'in'),
                                                   ('space',
                                                    ('MSpace', 'Space'),
                                                    'in')],
                                          'defaults': {'space': ('MSpace',
                                                                 'Space',
                                                                 'kObject')},
                                          'deprecated': False,
                                          'doc': '\r\nSet the normal array (user normals)',
                                          'inArgs': ['normals', 'space'],
                                          'inverse': ('getNormals', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'normals': ['&'],
                                                             'space': []},
                                          'types': {'normals': 'MFloatVectorArray',
                                                    'space': ('MSpace',
                                                              'Space')}}],
                          'setPinUVs': [{'argInfo': {'pinData': {'doc': 'The list of pin weights. ',
                                                                 'type': 'MDoubleArray'},
                                                     'uvIds': {'doc': 'The list of pin uvs ids. ',
                                                               'type': 'MUintArray'},
                                                     'uvSet': {'doc': 'UV set to work with.',
                                                               'type': 'MString'}},
                                         'args': [('uvIds',
                                                   'MUintArray',
                                                   'in'),
                                                  ('pinData',
                                                   'MDoubleArray',
                                                   'in'),
                                                  ('uvSet',
                                                   'MString',
                                                   'in')],
                                         'defaults': {'uvSet': None},
                                         'deprecated': False,
                                         'doc': '\r\nThis method sets the specified uvs of the mesh as "pinned" uvs, a "pinned" uv is one which should not be modified. If pin weight is set to 1.0 then it becomes fully pinned and uv tools should not modify that uv. If the pin weight is set to a value between 0.0 and 1.0 then uv tools should weight their changes to that uv accordingly.',
                                         'inArgs': ['uvIds',
                                                    'pinData',
                                                    'uvSet'],
                                         'inverse': ('getPinUVs', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'pinData': ['const',
                                                                        '&'],
                                                            'uvIds': ['const',
                                                                      '&'],
                                                            'uvSet': ['const',
                                                                      '*']},
                                         'types': {'pinData': 'MDoubleArray',
                                                   'uvIds': 'MUintArray',
                                                   'uvSet': 'MString'}}],
                          'setPoint': [{'argInfo': {'pos': {'doc': 'The new value for the vertex ',
                                                            'type': 'MPoint'},
                                                    'space': {'doc': 'Specifies the coordinate system for this operation',
                                                              'type': ('MSpace',
                                                                       'Space')},
                                                    'vertexId': {'doc': 'The object-relative (mesh-relative/global) index of the vertex to be changed ',
                                                                 'type': 'int'}},
                                        'args': [('vertexId',
                                                  'int',
                                                  'in'),
                                                 ('pos', 'MPoint', 'in'),
                                                 ('space',
                                                  ('MSpace', 'Space'),
                                                  'in')],
                                        'defaults': {'space': ('MSpace',
                                                               'Space',
                                                               'kObject')},
                                        'deprecated': False,
                                        'doc': '\r\nSets the position of specified vertex in the vertex list for this mesh.',
                                        'inArgs': ['vertexId',
                                                   'pos',
                                                   'space'],
                                        'inverse': ('getPoint', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'pos': ['const',
                                                                   '&'],
                                                           'space': [],
                                                           'vertexId': []},
                                        'types': {'pos': 'MPoint',
                                                  'space': ('MSpace',
                                                            'Space'),
                                                  'vertexId': 'int'}}],
                          'setPoints': [{'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation',
                                                               'type': ('MSpace',
                                                                        'Space')},
                                                     'vertexArray': {'doc': 'Storage for the vertex list ',
                                                                     'type': 'MFloatPointArray'}},
                                         'args': [(u'vertexArray',
                                                   'MFloatPointArray',
                                                   u'in'),
                                                  (u'space',
                                                   ('MSpace', 'Space'),
                                                   'in')],
                                         'defaults': {'space': ('MSpace',
                                                                'Space',
                                                                'kObject')},
                                         'deprecated': False,
                                         'doc': '\r\nThis method copies the points in the given point array to the vertices of this polygon.',
                                         'inArgs': [u'vertexArray',
                                                    u'space'],
                                         'inverse': ('getPoints', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'space': [],
                                                            'vertexArray': ['&']},
                                         'types': {'space': ('MSpace',
                                                             'Space'),
                                                   'vertexArray': 'MFloatPointArray'}},
                                        {'argInfo': {'space': {'doc': 'Specifies the coordinate system for this operation',
                                                               'type': ('MSpace',
                                                                        'Space')},
                                                     'vertexArray': {'doc': 'Storage for the vertex list ',
                                                                     'type': 'MPointArray'}},
                                         'args': [(u'vertexArray',
                                                   'MPointArray',
                                                   u'in'),
                                                  (u'space',
                                                   ('MSpace', 'Space'),
                                                   'in')],
                                         'defaults': {'space': ('MSpace',
                                                                'Space',
                                                                'kObject')},
                                         'deprecated': False,
                                         'doc': '\r\nThis method copies the points in the given point array to the vertices of this mesh.',
                                         'inArgs': [u'vertexArray',
                                                    u'space'],
                                         'inverse': ('getPoints', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'space': [],
                                                            'vertexArray': ['&']},
                                         'types': {'space': ('MSpace',
                                                             'Space'),
                                                   'vertexArray': 'MPointArray'}}],
                          'setSmoothMeshDisplayOptions': [{'argInfo': {'options': {'doc': 'Options to set',
                                                                                   'type': 'MMeshSmoothOptions'}},
                                                           'args': [('options',
                                                                     'MMeshSmoothOptions',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSets the current display smoothing options for the mesh',
                                                           'inArgs': ['options'],
                                                           'inverse': ('getSmoothMeshDisplayOptions',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'options': ['const',
                                                                                          '&']},
                                                           'types': {'options': 'MMeshSmoothOptions'}}],
                          'setSomeColors': [{'argInfo': {'colorArray': {'doc': 'The array of color values to be set ',
                                                                        'type': 'MColorArray'},
                                                         'colorIds': {'doc': 'The array of colorIds to set values for ',
                                                                      'type': 'MIntArray'},
                                                         'colorSet': {'doc': 'Color set to work with',
                                                                      'type': 'MString'}},
                                             'args': [('colorIds',
                                                       'MIntArray',
                                                       'in'),
                                                      ('colorArray',
                                                       'MColorArray',
                                                       'in'),
                                                      ('colorSet',
                                                       'MString',
                                                       'in')],
                                             'defaults': {'colorSet': None},
                                             'deprecated': False,
                                             'doc': '\r\nSets the specified colors for this mesh. If the largest colorId in the array is larger than  numColors()  then the color list for this mesh will be grown to accommodate the new color values.',
                                             'inArgs': ['colorIds',
                                                        'colorArray',
                                                        'colorSet'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'colorArray': ['const',
                                                                               '&'],
                                                                'colorIds': ['const',
                                                                             '&'],
                                                                'colorSet': ['const',
                                                                             '*']},
                                             'types': {'colorArray': 'MColorArray',
                                                       'colorIds': 'MIntArray',
                                                       'colorSet': 'MString'}},
                                            {'argInfo': {'colorArray': {'doc': 'The array of color values to be set ',
                                                                        'type': 'MColorArray'},
                                                         'colorIds': {'doc': 'The array of colorIds to set values for ',
                                                                      'type': 'MIntArray'},
                                                         'colorSet': {'doc': 'Color set to work with ',
                                                                      'type': 'MString'},
                                                         'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                 'type': ('MFnMesh',
                                                                          'MColorRepresentation')}},
                                             'args': [('colorIds',
                                                       'MIntArray',
                                                       'in'),
                                                      ('colorArray',
                                                       'MColorArray',
                                                       'in'),
                                                      ('colorSet',
                                                       'MString',
                                                       'in'),
                                                      ('rep',
                                                       ('MFnMesh',
                                                        'MColorRepresentation'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the specified colors of specified channels for this mesh.',
                                             'inArgs': ['colorIds',
                                                        'colorArray',
                                                        'colorSet',
                                                        'rep'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'colorArray': ['const',
                                                                               '&'],
                                                                'colorIds': ['const',
                                                                             '&'],
                                                                'colorSet': ['const',
                                                                             '*'],
                                                                'rep': []},
                                             'types': {'colorArray': 'MColorArray',
                                                       'colorIds': 'MIntArray',
                                                       'colorSet': 'MString',
                                                       'rep': ('MFnMesh',
                                                               'MColorRepresentation')}}],
                          'setSomeUVs': [{'argInfo': {'uArray': {'doc': 'The array of u values to be set ',
                                                                 'type': 'MFloatArray'},
                                                      'uvIds': {'doc': 'The array of uvIds to set values for ',
                                                                'type': 'MIntArray'},
                                                      'uvSet': {'doc': 'UV set to work with',
                                                                'type': 'MString'},
                                                      'vArray': {'doc': 'The array of v values to be set ',
                                                                 'type': 'MFloatArray'}},
                                          'args': [('uvIds',
                                                    'MIntArray',
                                                    'in'),
                                                   ('uArray',
                                                    'MFloatArray',
                                                    'in'),
                                                   ('vArray',
                                                    'MFloatArray',
                                                    'in'),
                                                   ('uvSet',
                                                    'MString',
                                                    'in')],
                                          'defaults': {'uvSet': None},
                                          'deprecated': False,
                                          'doc': "\r\nSets the specified texture coordinates (UV's) for this mesh. The uv arrays and uvId array must be of equal size. If the largest uvId in the array is larger than  numUVs()  then the uv list for this mesh will be grown to accommodate the new uv values. If a named uv set is given, the array will be grown when the largest uvId is larger than numUVs(uvSet).",
                                          'inArgs': ['uvIds',
                                                     'uArray',
                                                     'vArray',
                                                     'uvSet'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'uArray': ['const',
                                                                        '&'],
                                                             'uvIds': ['const',
                                                                       '&'],
                                                             'uvSet': ['const',
                                                                       '*'],
                                                             'vArray': ['const',
                                                                        '&']},
                                          'types': {'uArray': 'MFloatArray',
                                                    'uvIds': 'MIntArray',
                                                    'uvSet': 'MString',
                                                    'vArray': 'MFloatArray'}}],
                          'setStringBlindData': [{'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compID': {'doc': 'The component to set the blind data for When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                         'type': 'int'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Attribute value',
                                                                       'type': 'MString'}},
                                                  'args': [('compID',
                                                            'int',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a value for a string blind data attribute.',
                                                  'inArgs': ['compID',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getStringBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compID': [],
                                                                     'compType': [],
                                                                     'data': []},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compID': 'int',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MString'}},
                                                 {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'Attribute value',
                                                                       'type': 'MString'}},
                                                  'args': [('compIDs',
                                                            'MIntArray',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a value for string blind data on an array of components',
                                                  'inArgs': ['compIDs',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getStringBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': []},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MString'}},
                                                 {'argInfo': {'attrName': {'doc': 'Attribute name ',
                                                                           'type': 'MString'},
                                                              'blindDataId': {'doc': 'The desired id for the new blind data type ',
                                                                              'type': 'int'},
                                                              'compIDs': {'doc': 'The components to set the blind data for When compType = MFn::kMeshFaceVertComponent then the elements of compIDs must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                          'type': 'MIntArray'},
                                                              'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                              'data': {'doc': 'The attribute values for each component',
                                                                       'type': 'MStringArray'}},
                                                  'args': [('compIDs',
                                                            'MIntArray',
                                                            'in'),
                                                           ('compType',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('blindDataId',
                                                            'int',
                                                            'in'),
                                                           ('attrName',
                                                            'MString',
                                                            'in'),
                                                           ('data',
                                                            'MStringArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet a values for a string blind data on an array of components. The arrays of values and components must be the same size.',
                                                  'inArgs': ['compIDs',
                                                             'compType',
                                                             'blindDataId',
                                                             'attrName',
                                                             'data'],
                                                  'inverse': ('getStringBlindData',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'attrName': [],
                                                                     'blindDataId': [],
                                                                     'compIDs': ['&'],
                                                                     'compType': [],
                                                                     'data': ['&']},
                                                  'types': {'attrName': 'MString',
                                                            'blindDataId': 'int',
                                                            'compIDs': 'MIntArray',
                                                            'compType': ('MFn',
                                                                         'Type'),
                                                            'data': 'MStringArray'}}],
                          'setUV': [{'argInfo': {'u': {'doc': 'The new u value that is to be set ',
                                                       'type': 'float'},
                                                 'uvId': {'doc': 'The element in the uv list to be set ',
                                                          'type': 'int'},
                                                 'uvSet': {'doc': 'UV set to work with',
                                                           'type': 'MString'},
                                                 'v': {'doc': 'The new v value that is to be set ',
                                                       'type': 'float'}},
                                     'args': [('uvId', 'int', 'in'),
                                              ('u', 'float', 'in'),
                                              ('v', 'float', 'in'),
                                              ('uvSet', 'MString', 'in')],
                                     'defaults': {'uvSet': None},
                                     'deprecated': False,
                                     'doc': '\r\nSets the specified texture coordinate. The uvId is the element in the uv list that will be set. If the uvId is greater than or equal to  numUVs()  then the uv list will be grown to accommodate the specified uv. If a named uv set is given, the largest uvId must be larger than numUVs(uvSet).',
                                     'inArgs': ['uvId',
                                                'u',
                                                'v',
                                                'uvSet'],
                                     'inverse': ('getUV', True),
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'u': [],
                                                        'uvId': [],
                                                        'uvSet': ['const',
                                                                  '*'],
                                                        'v': []},
                                     'types': {'u': 'float',
                                               'uvId': 'int',
                                               'uvSet': 'MString',
                                               'v': 'float'}}],
                          'setUVs': [{'argInfo': {'uArray': {'doc': 'The array of u values to be set ',
                                                             'type': 'MFloatArray'},
                                                  'uvSet': {'doc': 'UV set to work with',
                                                            'type': 'MString'},
                                                  'vArray': {'doc': 'The array of v values to be set ',
                                                             'type': 'MFloatArray'}},
                                      'args': [('uArray',
                                                'MFloatArray',
                                                'in'),
                                               ('vArray',
                                                'MFloatArray',
                                                'in'),
                                               ('uvSet',
                                                'MString',
                                                'in')],
                                      'defaults': {'uvSet': None},
                                      'deprecated': False,
                                      'doc': "\r\nSets all of the texture coordinates (uv's) for this mesh. The uv arrays must be of equal size and must be at least as large as the current UV set size. You can determine the UV set size by calling  numUVs()  for the default UV set, or numUVs(uvSet) for a named UV set.",
                                      'inArgs': ['uArray',
                                                 'vArray',
                                                 'uvSet'],
                                      'inverse': ('getUVs', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'uArray': ['const',
                                                                    '&'],
                                                         'uvSet': ['const',
                                                                   '*'],
                                                         'vArray': ['const',
                                                                    '&']},
                                      'types': {'uArray': 'MFloatArray',
                                                'uvSet': 'MString',
                                                'vArray': 'MFloatArray'}}],
                          'setVertexColor': [{'argInfo': {'color': {'doc': 'The color to set ',
                                                                    'type': 'MColor'},
                                                          'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                       'type': 'MDGModifier'},
                                                          'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index to set it for ',
                                                                          'type': 'int'}},
                                              'args': [('color',
                                                        'MColor',
                                                        'in'),
                                                       ('vertexIndex',
                                                        'int',
                                                        'in'),
                                                       ('modifier',
                                                        'MDGModifier',
                                                        'in')],
                                              'defaults': {'modifier': None},
                                              'deprecated': False,
                                              'doc': '\r\nSet color for this vertex. The color is set for the vertex-face in each face that the vertex belongs to.',
                                              'inArgs': ['color',
                                                         'vertexIndex',
                                                         'modifier'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'color': ['&'],
                                                                 'modifier': ['*'],
                                                                 'vertexIndex': []},
                                              'types': {'color': 'MColor',
                                                        'modifier': 'MDGModifier',
                                                        'vertexIndex': 'int'}},
                                             {'argInfo': {'color': {'doc': 'The color to set ',
                                                                    'type': 'MColor'},
                                                          'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                       'type': 'MDGModifier'},
                                                          'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                  'type': ('MFnMesh',
                                                                           'MColorRepresentation')},
                                                          'vertexIndex': {'doc': 'The object-relative (mesh-relative/global) vertex index to set it for ',
                                                                          'type': 'int'}},
                                              'args': [('color',
                                                        'MColor',
                                                        'in'),
                                                       ('vertexIndex',
                                                        'int',
                                                        'in'),
                                                       ('modifier',
                                                        'MDGModifier',
                                                        'in'),
                                                       ('rep',
                                                        ('MFnMesh',
                                                         'MColorRepresentation'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet color of specified channels for this vertex. The color is set for the vertex-face in each face that the vertex belongs to.',
                                              'inArgs': ['color',
                                                         'vertexIndex',
                                                         'modifier',
                                                         'rep'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'color': ['&'],
                                                                 'modifier': ['*'],
                                                                 'rep': [],
                                                                 'vertexIndex': []},
                                              'types': {'color': 'MColor',
                                                        'modifier': 'MDGModifier',
                                                        'rep': ('MFnMesh',
                                                                'MColorRepresentation'),
                                                        'vertexIndex': 'int'}}],
                          'setVertexColors': [{'argInfo': {'colors': {'doc': 'The colors to set ',
                                                                      'type': 'MColorArray'},
                                                           'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                        'type': 'MDGModifier'},
                                                           'vertexList': {'doc': 'The vertices to set it for ',
                                                                          'type': 'MIntArray'}},
                                               'args': [('colors',
                                                         'MColorArray',
                                                         'in'),
                                                        ('vertexList',
                                                         'MIntArray',
                                                         'in'),
                                                        ('modifier',
                                                         'MDGModifier',
                                                         'in')],
                                               'defaults': {'modifier': None},
                                               'deprecated': False,
                                               'doc': '\r\nSet color for these vertices.',
                                               'inArgs': ['colors',
                                                          'vertexList',
                                                          'modifier'],
                                               'inverse': ('getVertexColors',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'colors': ['&'],
                                                                  'modifier': ['*'],
                                                                  'vertexList': ['&']},
                                               'types': {'colors': 'MColorArray',
                                                         'modifier': 'MDGModifier',
                                                         'vertexList': 'MIntArray'}},
                                              {'argInfo': {'colors': {'doc': 'The colors to set ',
                                                                      'type': 'MColorArray'},
                                                           'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method. ',
                                                                        'type': 'MDGModifier'},
                                                           'rep': {'doc': 'The RGB/RGBA/A channel(s) to set',
                                                                   'type': ('MFnMesh',
                                                                            'MColorRepresentation')},
                                                           'vertexList': {'doc': 'The vertices to set it for ',
                                                                          'type': 'MIntArray'}},
                                               'args': [('colors',
                                                         'MColorArray',
                                                         'in'),
                                                        ('vertexList',
                                                         'MIntArray',
                                                         'in'),
                                                        ('modifier',
                                                         'MDGModifier',
                                                         'in'),
                                                        ('rep',
                                                         ('MFnMesh',
                                                          'MColorRepresentation'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet color of specified channels for these vertices.',
                                               'inArgs': ['colors',
                                                          'vertexList',
                                                          'modifier',
                                                          'rep'],
                                               'inverse': ('getVertexColors',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'colors': ['&'],
                                                                  'modifier': ['*'],
                                                                  'rep': [],
                                                                  'vertexList': ['&']},
                                               'types': {'colors': 'MColorArray',
                                                         'modifier': 'MDGModifier',
                                                         'rep': ('MFnMesh',
                                                                 'MColorRepresentation'),
                                                         'vertexList': 'MIntArray'}}],
                          'setVertexNormal': [{'argInfo': {'modifier': {'doc': 'Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.',
                                                                        'type': 'MDGModifier'},
                                                           'normalIn': {'doc': 'The normal to set ',
                                                                        'type': 'MVector'},
                                                           'space': {'doc': 'World space or Object space ',
                                                                     'type': ('MSpace',
                                                                              'Space')},
                                                           'vertexId': {'doc': 'The object-relative (mesh-relative/global) vertex index to set it for ',
                                                                        'type': 'int'}},
                                               'args': [('normalIn',
                                                         'MVector',
                                                         'in'),
                                                        ('vertexId',
                                                         'int',
                                                         'in'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in'),
                                                        ('modifier',
                                                         'MDGModifier',
                                                         'in')],
                                               'defaults': {'modifier': None,
                                                            'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nSet Shared Normal for this vertex',
                                               'inArgs': ['normalIn',
                                                          'vertexId',
                                                          'space',
                                                          'modifier'],
                                               'inverse': ('getVertexNormal',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'modifier': ['*'],
                                                                  'normalIn': ['&'],
                                                                  'space': [],
                                                                  'vertexId': []},
                                               'types': {'modifier': 'MDGModifier',
                                                         'normalIn': 'MVector',
                                                         'space': ('MSpace',
                                                                   'Space'),
                                                         'vertexId': 'int'}}],
                          'setVertexNormals': [{'argInfo': {'normalsIn': {'doc': 'The normals to set ',
                                                                          'type': 'MVectorArray'},
                                                            'space': {'doc': 'World space or Object space',
                                                                      'type': ('MSpace',
                                                                               'Space')},
                                                            'vertexList': {'doc': 'The object-relative (mesh-relative/global) vertex indices to set them for ',
                                                                           'type': 'MIntArray'}},
                                                'args': [('normalsIn',
                                                          'MVectorArray',
                                                          'in'),
                                                         ('vertexList',
                                                          'MIntArray',
                                                          'in'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nSet Shared Normals for these vertices. The length of the normalsIn array should be same as the length of the vertexList array.',
                                                'inArgs': ['normalsIn',
                                                           'vertexList',
                                                           'space'],
                                                'inverse': ('getVertexNormals',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'normalsIn': ['&'],
                                                                   'space': [],
                                                                   'vertexList': ['&']},
                                                'types': {'normalsIn': 'MVectorArray',
                                                          'space': ('MSpace',
                                                                    'Space'),
                                                          'vertexList': 'MIntArray'}}],
                          'sortIntersectionFaceTriIds': [{'argInfo': {'faceIds': {'doc': 'Face IDs to be sorted. ',
                                                                                  'type': 'MIntArray'},
                                                                      'triIds': {'doc': 'Triangle IDs to be sorted.',
                                                                                 'type': 'MIntArray'}},
                                                          'args': [('faceIds',
                                                                    'MIntArray',
                                                                    'in'),
                                                                   ('triIds',
                                                                    'MIntArray',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nConvenience routine for sorting faceIds or face/triangle ids before passing them into the  closestIntersection() ,  allIntersections() , or  anyIntersection()  methods. When using an acceleration structure with the intersection operation, it is essential that any faceId or faceId/triId arrays be sorted properly to ensure optimal performance.',
                                                          'inArgs': ['faceIds',
                                                                     'triIds'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'faceIds': ['*'],
                                                                             'triIds': ['*']},
                                                          'types': {'faceIds': 'MIntArray',
                                                                    'triIds': 'MIntArray'}}],
                          'split': [{'argInfo': {'edgeFactors': {'doc': 'array of factors in the range [0,1] that represent how far along each edge must the split be done. This array must have the same number of elements as the edgeList array. ',
                                                                 'type': 'MFloatArray'},
                                                 'edgeList': {'doc': 'array of edge IDs to be split, in order of their appearance in the split. There must be as many elements in this array as there are SplitPlacement::kOnEdge elements in the placements array. ',
                                                              'type': 'MIntArray'},
                                                 'internalPoints': {'doc': 'array of positions for the vertices that will be added inside existing faces. There must be as many elements in this array as there are SplitPlacement::kInternalPoint elements in the placements array. This array can be empty. Internal points should be specified on the face between the previous edge id and the next edge id.',
                                                                    'type': 'MFloatPointArray'},
                                                 'placements': {'doc': 'array that contains elements of the SplitPlacement enumeration. They represent where to place the new vertices for the split. ',
                                                                'type': 'MIntArray'}},
                                     'args': [('placements',
                                               'MIntArray',
                                               'in'),
                                              ('edgeList',
                                               'MIntArray',
                                               'in'),
                                              ('edgeFactors',
                                               'MFloatArray',
                                               'in'),
                                              ('internalPoints',
                                               'MFloatPointArray',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nThis function splits a set of edges and faces in a continuous manner.',
                                     'inArgs': ['placements',
                                                'edgeList',
                                                'edgeFactors',
                                                'internalPoints'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'edgeFactors': ['&'],
                                                        'edgeList': ['&'],
                                                        'internalPoints': ['&'],
                                                        'placements': ['&']},
                                     'types': {'edgeFactors': 'MFloatArray',
                                               'edgeList': 'MIntArray',
                                               'internalPoints': 'MFloatPointArray',
                                               'placements': 'MIntArray'}}],
                          'stringBlindDataComponentId': [{'argInfo': {'attrName': {'doc': 'The attribute name ',
                                                                                   'type': 'MString'},
                                                                      'blindDataId': {'doc': 'The blind data id to check for ',
                                                                                      'type': 'int'},
                                                                      'compID': {'doc': 'The component to get for blind data on When compType = MFn::kMeshFaceVertComponent then compID must be obtained by calling MFnMesh::getFaceVertexBlindDataIndex(faceIndex,vertexIndex) ',
                                                                                 'type': 'int'},
                                                                      'compType': {'doc': 'The component type e.g. MFn::kMeshVertComponent ',
                                                                                   'type': ('MFn',
                                                                                            'Type')}},
                                                          'args': [('compID',
                                                                    'int',
                                                                    'in'),
                                                                   ('compType',
                                                                    ('MFn',
                                                                     'Type'),
                                                                    'in'),
                                                                   ('blindDataId',
                                                                    'int',
                                                                    'in'),
                                                                   ('attrName',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGet the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.',
                                                          'inArgs': ['compID',
                                                                     'compType',
                                                                     'blindDataId',
                                                                     'attrName'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Blind data.',
                                                                         'qualifiers': [],
                                                                         'type': 'MString'},
                                                          'returnType': 'MString',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'attrName': [],
                                                                             'blindDataId': [],
                                                                             'compID': [],
                                                                             'compType': []},
                                                          'types': {'attrName': 'MString',
                                                                    'blindDataId': 'int',
                                                                    'compID': 'int',
                                                                    'compType': ('MFn',
                                                                                 'Type')}}],
                          'subdivideEdges': [{'argInfo': {'divisionCount': {'doc': 'number of subsequent subdivisions to do',
                                                                            'type': 'int'},
                                                          'edgeList': {'doc': 'array of edge component IDs to be subdivided ',
                                                                       'type': 'MIntArray'}},
                                              'args': [('edgeList',
                                                        'MIntArray',
                                                        'in'),
                                                       ('divisionCount',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis function subdivides edges at regular intervals. The divisionCount argument is the number of subdivisions per edges and represents the number of new vertices created on each edge.',
                                              'inArgs': ['edgeList',
                                                         'divisionCount'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'divisionCount': [],
                                                                 'edgeList': ['&']},
                                              'types': {'divisionCount': 'int',
                                                        'edgeList': 'MIntArray'}}],
                          'subdivideFaces': [{'argInfo': {'divisionCount': {'doc': 'number of subsequent subdivisions to do',
                                                                            'type': 'int'},
                                                          'faceList': {'doc': 'array of face IDs to subdivide ',
                                                                       'type': 'MIntArray'}},
                                              'args': [('faceList',
                                                        'MIntArray',
                                                        'in'),
                                                       ('divisionCount',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis function subdivides multiple faces. This method only accepts faces that are three of four-sided. The operation adds a vertex in the middle of each given face and connects it to the middle of every edge in the given face. This results in three or four new faces for each original face.',
                                              'inArgs': ['faceList',
                                                         'divisionCount'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'divisionCount': [],
                                                                 'faceList': ['&']},
                                              'types': {'divisionCount': 'int',
                                                        'faceList': 'MIntArray'}}],
                          'syncObject': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nIf a non-api operation happens that many have changed the underlying Maya object wrapped by this api object, make sure that the api object references a valid maya object. In particular this call should be used if you are calling mel commands from your plugin. Note that this only applies for mesh shapes: in a plugin node where the dataMesh is being accessed directly this is not necessary.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nFunction set type. \r\n',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': ('MFn',
                                                            'Type')},
                                    'returnType': ('MFn', 'Type'),
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                          'uniformGridParams': [{'argInfo': {'xDiv': {'doc': 'Number of voxels in the x direction ',
                                                                      'type': 'int'},
                                                             'yDiv': {'doc': 'Number of voxels in the y direction ',
                                                                      'type': 'int'},
                                                             'zDiv': {'doc': 'Number of voxels in the z direction',
                                                                      'type': 'int'}},
                                                 'args': [('xDiv',
                                                           'int',
                                                           'in'),
                                                          ('yDiv',
                                                           'int',
                                                           'in'),
                                                          ('zDiv',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreates a  MMeshIsectAccelParams  configuration object that can be passed to several of the geometric query methods available on  MFnMesh . For example, the  MFnMesh  closest point and intersection methods can optionally make use of this object to speed up their operation.',
                                                 'inArgs': ['xDiv',
                                                            'yDiv',
                                                            'zDiv'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Intersection accelerator object. ',
                                                                'qualifiers': [],
                                                                'type': 'MMeshIsectAccelParams'},
                                                 'returnType': 'MMeshIsectAccelParams',
                                                 'static': True,
                                                 'typeQualifiers': {'xDiv': [],
                                                                    'yDiv': [],
                                                                    'zDiv': []},
                                                 'types': {'xDiv': 'int',
                                                           'yDiv': 'int',
                                                           'zDiv': 'int'}}],
                          'unlockFaceVertexNormals': [{'argInfo': {'faceList': {'doc': 'The faces to unlock normal in ',
                                                                                'type': 'MIntArray'},
                                                                   'vertexList': {'doc': 'The corresponding object-relative (global) vertex indices to unlock them for',
                                                                                  'type': 'MIntArray'}},
                                                       'args': [('faceList',
                                                                 'MIntArray',
                                                                 'in'),
                                                                ('vertexList',
                                                                 'MIntArray',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nUnlock Normals for these face/vertex pairs',
                                                       'inArgs': ['faceList',
                                                                  'vertexList'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'faceList': ['&'],
                                                                          'vertexList': ['&']},
                                                       'types': {'faceList': 'MIntArray',
                                                                 'vertexList': 'MIntArray'}}],
                          'unlockVertexNormals': [{'argInfo': {'vertexList': {'doc': 'The vertices to unlock normals for',
                                                                              'type': 'MIntArray'}},
                                                   'args': [('vertexList',
                                                             'MIntArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nUnlock Shared Normals for these vertices',
                                                   'inArgs': ['vertexList'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'vertexList': ['&']},
                                                   'types': {'vertexList': 'MIntArray'}}],
                          'updateSurface': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSignal that this polygonal mesh has changed and needs to redraw itself.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
              'pymelEnums': {'BoolOperation': "Enum('BoolOperation', [('union', 1), ('kUnion', 1), ('difference', 2), ('kDifference', 2), ('intersection', 3), ('kIntersection', 3)], multiKeys=True)",
                             'MColorRepresentation': "Enum('MColorRepresentation', [('alpha', 1), ('kAlpha', 1), ('RGB', 3), ('kRGB', 3), ('RGBA', 4), ('kRGBA', 4)], multiKeys=True)",
                             'SplitPlacement': "Enum('SplitPlacement', [('onEdge', 0), ('kOnEdge', 0), ('internalPoint', 1), ('kInternalPoint', 1), ('invalid', 2), ('kInvalid', 2)], multiKeys=True)"},
              'pymelMethods': {'currentColorSetName': 'getCurrentColorSetName',
                               'currentUVSetName': 'getCurrentUVSetName',
                               'displayColors': 'getDisplayColors',
                               'setIsColorClamped': 'setColorClamped'}},
  'MFnMeshData': {'enums': {},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nClass name. \r\n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'create': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Mesh.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The new MObject ',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nFunction set type. \r\n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MFn',
                                                                'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}]},
                  'pymelEnums': {}},
  'MFnMessageAttribute': {'enums': {},
                          'methods': {'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nClass name. \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'create': [{'argInfo': {'briefName': {'doc': 'The brief name of the attribute ',
                                                                            'type': 'MString'},
                                                              'fullName': {'doc': 'The full name of the attribute ',
                                                                           'type': 'MString'}},
                                                  'args': [('fullName',
                                                            'MString',
                                                            'in'),
                                                           ('briefName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nCreates a Message attribute object.',
                                                  'inArgs': ['fullName',
                                                             'briefName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The newly created Message attribute object.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'briefName': ['const',
                                                                                   '&'],
                                                                     'fullName': ['const',
                                                                                  '&']},
                                                  'types': {'briefName': 'MString',
                                                            'fullName': 'MString'}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nFunction set type. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {}},
  'MFnMotionPath': {'enums': {'Axis': {'valueDocs': {'kXaxis': '',
                                                     'kYaxis': '',
                                                     'kZaxis': '',
                                                     'xaxis': '',
                                                     'yaxis': '',
                                                     'zaxis': ''},
                                       'values': "Enum('Axis', {'kXaxis': 0, 'kYaxis': 1, 'kZaxis': 2})"}},
                    'invertibles': [('setUTimeStart', 'uTimeStart'),
                                    ('setUStart', 'uStart'),
                                    ('setPathObject', 'pathObject'),
                                    ('setUpAxis', 'upAxis'),
                                    ('setInverseNormal', 'inverseNormal'),
                                    ('setUTimeEnd', 'uTimeEnd'),
                                    ('setUEnd', 'uEnd'),
                                    ('setBankScale', 'bankScale'),
                                    ('setFollowAxis', 'followAxis'),
                                    ('setBankThreshold', 'bankThreshold'),
                                    ('setUseNormal', 'useNormal'),
                                    ('setBank', 'bank'),
                                    ('setFollow', 'follow')],
                    'methods': {'addAnimatedObject': [{'argInfo': {'modifier': {'doc': 'The object that will hold the undo information',
                                                                                'type': 'MDGModifier'},
                                                                   'objectToAnimate': {'doc': 'A DAG path to the animated object ',
                                                                                       'type': 'MDagPath'}},
                                                       'args': [('objectToAnimate',
                                                                 'MDagPath',
                                                                 'in'),
                                                                ('modifier',
                                                                 'MDGModifier',
                                                                 'in')],
                                                       'defaults': {'modifier': None},
                                                       'deprecated': False,
                                                       'doc': '\r\nAdd an object to be animated along this motion path.',
                                                       'inArgs': ['objectToAnimate',
                                                                  'modifier'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'modifier': ['*'],
                                                                          'objectToAnimate': ['const',
                                                                                              '&']},
                                                       'types': {'modifier': 'MDGModifier',
                                                                 'objectToAnimate': 'MDagPath'}}],
                                'bank': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermines whether bank has been enabled for this motion path.',
                                          'inArgs': [],
                                          'inverse': ('setBank', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true Bank is enabled  false Bank is disabled  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                                'bankScale': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the bank scale for this motion path.',
                                               'inArgs': [],
                                               'inverse': ('setBankScale',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The bank scale.',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                'bankThreshold': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the bank threshold for this motion path. The bank threshold is used to specify the maximum bank angle. The default value is 90 degrees.',
                                                   'inArgs': [],
                                                   'inverse': ('setBankThreshold',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The bank threshold.',
                                                                  'qualifiers': [],
                                                                  'type': 'double'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {'modifier': {'doc': 'this object will hold the undo information ',
                                                                     'type': 'MDGModifier'},
                                                        'objectToAnimate': {'doc': 'the object that will follow the motion path ',
                                                                            'type': 'MDagPath'},
                                                        'pathObject': {'doc': 'the curve, surface, or curve-on-surface to use as the object path ',
                                                                       'type': 'MDagPath'},
                                                        'timeEnd': {'doc': 'the time at which to end the animation ',
                                                                    'type': 'MTime'},
                                                        'timeStart': {'doc': 'the time at which to start the animation ',
                                                                      'type': 'MTime'}},
                                            'args': [('pathObject',
                                                      'MDagPath',
                                                      'in'),
                                                     ('objectToAnimate',
                                                      'MDagPath',
                                                      'in'),
                                                     ('timeStart',
                                                      'MTime',
                                                      'in'),
                                                     ('timeEnd',
                                                      'MTime',
                                                      'in'),
                                                     ('modifier',
                                                      'MDGModifier',
                                                      'in')],
                                            'defaults': {'modifier': None},
                                            'deprecated': False,
                                            'doc': '\r\nCreate a new motion path dependency node. When a motion path node is created, the following defaults are set:',
                                            'inArgs': ['pathObject',
                                                       'objectToAnimate',
                                                       'timeStart',
                                                       'timeEnd',
                                                       'modifier'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The new motion path node',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'modifier': ['*'],
                                                               'objectToAnimate': ['const',
                                                                                   '&'],
                                                               'pathObject': ['const',
                                                                              '&'],
                                                               'timeEnd': ['&'],
                                                               'timeStart': ['&']},
                                            'types': {'modifier': 'MDGModifier',
                                                      'objectToAnimate': 'MDagPath',
                                                      'pathObject': 'MDagPath',
                                                      'timeEnd': 'MTime',
                                                      'timeStart': 'MTime'}}],
                                'follow': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDetermines whether follow is set for this motion path node.',
                                            'inArgs': [],
                                            'inverse': ('setFollow',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true Follow is turned on  false Follow is turned off  ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'followAxis': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the follow axis for this motion path.',
                                                'inArgs': [],
                                                'inverse': ('setFollowAxis',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The follow axis.',
                                                               'qualifiers': [],
                                                               'type': ('MFnMotionPath',
                                                                        'Axis')},
                                                'returnType': ('MFnMotionPath',
                                                               'Axis'),
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'getAnimatedObjects': [{'argInfo': {'array': {'doc': 'Storage for the dag paths.',
                                                                              'type': 'MDagPathArray'}},
                                                        'args': [('array',
                                                                  'MDagPathArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns an array of dag paths to the animated objects for this motion path.',
                                                        'inArgs': [],
                                                        'outArgs': ['array'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'array': ['&']},
                                                        'types': {'array': 'MDagPathArray'}}],
                                'getOrientationMarker': [{'argInfo': {'markerNum': {'doc': 'The number of the marker ',
                                                                                    'type': 'uint'}},
                                                          'args': [('markerNum',
                                                                    'uint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGets the orientation marker where markerNum is the order in which the marker was created.',
                                                          'inArgs': ['markerNum'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The orientation marker',
                                                                         'qualifiers': [],
                                                                         'type': 'MObject'},
                                                          'returnType': 'MObject',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'markerNum': ['unsigned']},
                                                          'types': {'markerNum': 'uint'}}],
                                'getPositionMarker': [{'argInfo': {'markerNum': {'doc': 'The number of the marker ',
                                                                                 'type': 'uint'}},
                                                       'args': [('markerNum',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGets the position marker where markerNum is the order in which the marker was created.',
                                                       'inArgs': ['markerNum'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The position marker',
                                                                      'qualifiers': [],
                                                                      'type': 'MObject'},
                                                       'returnType': 'MObject',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'markerNum': ['unsigned']},
                                                       'types': {'markerNum': 'uint'}}],
                                'inverseNormal': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermines whether the up-axis of the animated object for this motion path is aligned to the opposite direction of the normal vector of the path geometry.',
                                                   'inArgs': [],
                                                   'inverse': ('setInverseNormal',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': ' true Inverse normal vector is used for object alignment.  false Inverse normal vector is not used for object alignment.  ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                'numOrientationMarkers': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns the number of orientation markers on this motion path.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The number of markers',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                'numPositionMarkers': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the number of position markers on this motion path.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The number of markers',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                'pathObject': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn a dag path to the motion path object. The motion path object is the curve/surface that animated objects of this node will move along.',
                                                'inArgs': [],
                                                'inverse': ('setPathObject',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The dag path of the motion path object',
                                                               'qualifiers': [],
                                                               'type': 'MDagPath'},
                                                'returnType': 'MDagPath',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'setBank': [{'argInfo': {'bank': {'doc': 'Specifies whether bank is turned on',
                                                                  'type': 'bool'}},
                                             'args': [('bank',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\n Parameters: \n \n [in]  bank  Specifies whether bank is turned on \n \n \n Returns: Status Code \n Status Codes: \n MS::kSuccess  Member was successful  \n MS::kFailure  An object error has occurred  \n \n \n',
                                             'inArgs': ['bank'],
                                             'inverse': ('bank', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'bank': []},
                                             'types': {'bank': 'bool'}}],
                                'setBankScale': [{'argInfo': {'bankScale': {'doc': 'The new bank scale value',
                                                                            'type': 'double'}},
                                                  'args': [('bankScale',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the bank scale for this motion path. If the computed bank angles are not large enough, the user can specify the bankScale to amplify them. The default value is 1.',
                                                  'inArgs': ['bankScale'],
                                                  'inverse': ('bankScale',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'bankScale': []},
                                                  'types': {'bankScale': 'double'}}],
                                'setBankThreshold': [{'argInfo': {'bankThreshold': {'doc': 'The new bank threshold value',
                                                                                    'type': 'double'}},
                                                      'args': [('bankThreshold',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the bank threshold for this motion path. The bank threshold is used to specify the maximum bank angle. The default value is 90 degrees.',
                                                      'inArgs': ['bankThreshold'],
                                                      'inverse': ('bankThreshold',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'bankThreshold': []},
                                                      'types': {'bankThreshold': 'double'}}],
                                'setFollow': [{'argInfo': {'modifier': {'doc': 'The object that will hold the undo information',
                                                                        'type': 'MDGModifier'},
                                                           'on': {'doc': 'Specifies whether follow is activated for this motion path ',
                                                                  'type': 'bool'}},
                                               'args': [('on',
                                                         'bool',
                                                         'in'),
                                                        ('modifier',
                                                         'MDGModifier',
                                                         'in')],
                                               'defaults': {'modifier': None},
                                               'deprecated': False,
                                               'doc': '\r\nSetting follow on will cause the animated object(s) local axis to be aligned with the tangent of the motion path. The default alignment axis is Y.',
                                               'inArgs': ['on',
                                                          'modifier'],
                                               'inverse': ('follow',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'modifier': ['*'],
                                                                  'on': []},
                                               'types': {'modifier': 'MDGModifier',
                                                         'on': 'bool'}}],
                                'setFollowAxis': [{'argInfo': {'axis': {'doc': 'Object axis to align with motion path tangent',
                                                                        'type': ('MFnMotionPath',
                                                                                 'Axis')}},
                                                   'args': [('axis',
                                                             ('MFnMotionPath',
                                                              'Axis'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the axis of the animated object that will follow the motion path. Possible alignment parameters are  kXaxis ,  kYaxiz , or  kZaxis .',
                                                   'inArgs': ['axis'],
                                                   'inverse': ('followAxis',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'axis': []},
                                                   'types': {'axis': ('MFnMotionPath',
                                                                      'Axis')}}],
                                'setInverseNormal': [{'argInfo': {'invert': {'doc': 'Specifies if inverse normal is used',
                                                                             'type': 'bool'}},
                                                      'args': [('invert',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nIf  true , enable alignment of the up axis of the moving object(s) to the opposite direction of the normal vector of the path geometry.',
                                                      'inArgs': ['invert'],
                                                      'inverse': ('inverseNormal',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'invert': []},
                                                      'types': {'invert': 'bool'}}],
                                'setPathObject': [{'argInfo': {'modifier': {'doc': 'The object that will hold the undo information',
                                                                            'type': 'MDGModifier'},
                                                               'pathObject': {'doc': 'The curve (or surface) that will be the motion path ',
                                                                              'type': 'MDagPath'}},
                                                   'args': [('pathObject',
                                                             'MDagPath',
                                                             'in'),
                                                            ('modifier',
                                                             'MDGModifier',
                                                             'in')],
                                                   'defaults': {'modifier': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the curve or surface for this motion path. All animated objects for this motion path will follow the new path that is specified.',
                                                   'inArgs': ['pathObject',
                                                              'modifier'],
                                                   'inverse': ('pathObject',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'modifier': ['*'],
                                                                      'pathObject': ['const',
                                                                                     '&']},
                                                   'types': {'modifier': 'MDGModifier',
                                                             'pathObject': 'MDagPath'}}],
                                'setUEnd': [{'argInfo': {'end': {'doc': 'the new end value',
                                                                 'type': 'double'}},
                                             'args': [('end',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the end value of the u parameterization for the animation.',
                                             'inArgs': ['end'],
                                             'inverse': ('uEnd', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'end': []},
                                             'types': {'end': 'double'}}],
                                'setUStart': [{'argInfo': {'start': {'doc': 'the new start value',
                                                                     'type': 'double'}},
                                               'args': [('start',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets the starting value of the u parameterization for the animation.',
                                               'inArgs': ['start'],
                                               'inverse': ('uStart',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'start': []},
                                               'types': {'start': 'double'}}],
                                'setUTimeEnd': [{'argInfo': {'end': {'doc': 'the new end time',
                                                                     'type': 'MTime'}},
                                                 'args': [('end',
                                                           'MTime',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the end time of the animation for the u parameter.',
                                                 'inArgs': ['end'],
                                                 'inverse': ('uTimeEnd',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'end': ['&']},
                                                 'types': {'end': 'MTime'}}],
                                'setUTimeStart': [{'argInfo': {'start': {'doc': 'the new start time',
                                                                         'type': 'MTime'}},
                                                   'args': [('start',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the starting time of the animation for the u parameter.',
                                                   'inArgs': ['start'],
                                                   'inverse': ('uTimeStart',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'start': ['&']},
                                                   'types': {'start': 'MTime'}}],
                                'setUpAxis': [{'argInfo': {'axis': {'doc': 'Axis to be set',
                                                                    'type': ('MFnMotionPath',
                                                                             'Axis')}},
                                               'args': [('axis',
                                                         ('MFnMotionPath',
                                                          'Axis'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the up-axis for this motion path.',
                                               'inArgs': ['axis'],
                                               'inverse': ('upAxis',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'axis': []},
                                               'types': {'axis': ('MFnMotionPath',
                                                                  'Axis')}}],
                                'setUseNormal': [{'argInfo': {'use': {'doc': 'Specifies if normal is used',
                                                                      'type': 'bool'}},
                                                  'args': [('use',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nIf  true , enables alignment of the up axis of the animated object to the normal vector of the path geometry.',
                                                  'inArgs': ['use'],
                                                  'inverse': ('useNormal',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'use': []},
                                                  'types': {'use': 'bool'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'uEnd': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the end value of the u parameterization for the animation.',
                                          'inArgs': [],
                                          'inverse': ('setUEnd', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The end value',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                                'uStart': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the starting value of the u parameterization for the animation.',
                                            'inArgs': [],
                                            'inverse': ('setUStart',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The starting value',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'uTimeEnd': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the end time of the animation for the u parameter.',
                                              'inArgs': [],
                                              'inverse': ('setUTimeEnd',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The end time',
                                                             'qualifiers': [],
                                                             'type': 'MTime'},
                                              'returnType': 'MTime',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                'uTimeStart': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the start time of the animation for the u parameter.',
                                                'inArgs': [],
                                                'inverse': ('setUTimeStart',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The starting time',
                                                               'qualifiers': [],
                                                               'type': 'MTime'},
                                                'returnType': 'MTime',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'upAxis': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the up-axis for this motion path.',
                                            'inArgs': [],
                                            'inverse': ('setUpAxis',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The up-axis for this motion path',
                                                           'qualifiers': [],
                                                           'type': ('MFnMotionPath',
                                                                    'Axis')},
                                            'returnType': ('MFnMotionPath',
                                                           'Axis'),
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'useNormal': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermines whether the up-axis of the animated object for this motion path is aligned with the normal vector of the path geometry.',
                                               'inArgs': [],
                                               'inverse': ('setUseNormal',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': ' true Normal vector is used for object alignment.  false Normal vector is not used for object alignment.  ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}]},
                    'pymelEnums': {'Axis': "Enum('Axis', [('xaxis', 0), ('kXaxis', 0), ('yaxis', 1), ('kYaxis', 1), ('zaxis', 2), ('kZaxis', 2)], multiKeys=True)"},
                    'pymelMethods': {'bank': 'getBank',
                                     'bankScale': 'getBankScale',
                                     'bankThreshold': 'getBankThreshold',
                                     'follow': 'getFollow',
                                     'followAxis': 'getFollowAxis',
                                     'inverseNormal': 'getInverseNormal',
                                     'pathObject': 'getPathObject',
                                     'uEnd': 'getUEnd',
                                     'uStart': 'getUStart',
                                     'uTimeEnd': 'getUTimeEnd',
                                     'uTimeStart': 'getUTimeStart',
                                     'upAxis': 'getUpAxis',
                                     'useNormal': 'getUseNormal'}},
  'MFnNIdData': {'enums': {},
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nClass name. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'create': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nCreates an underlying Maya nId data object and return it as an  MObject',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'getObjectPtr': [{'argInfo': {'ptr': {'doc': 'Storage to return the pointer to the N constraint',
                                                                   'type': 'MnObject'}},
                                               'args': [('ptr',
                                                         'MnObject',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nNO SCRIPT SUPPORT. \n',
                                               'inArgs': [],
                                               'outArgs': ['ptr'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'ptr': ['*&']},
                                               'types': {'ptr': 'MnObject'}},
                                              {'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nGet the nObject pointer',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the pointer to the N constraint',
                                                              'qualifiers': ['*'],
                                                              'type': 'MnObject'},
                                               'returnType': 'MnObject',
                                               'static': False,
                                               'typeQualifiers': {'status': ['*']},
                                               'types': {}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nFunction set type. \n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': ('MFn',
                                                               'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                 'pymelEnums': {}},
  'MFnNObjectData': {'enums': {},
                     'invertibles': [('setCached', 'getCached'),
                                     ('setObjectPtr', 'getObjectPtr')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClass name. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCreates an underlying Maya N data object and return it as an  MObject',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The newly object. ',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                 'getCached': [{'argInfo': {'cached': {'doc': 'the cache state',
                                                                       'type': 'bool'}},
                                                'args': [('cached',
                                                          'bool',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                'inArgs': [],
                                                'inverse': ('setCached',
                                                            False),
                                                'outArgs': ['cached'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'cached': ['&']},
                                                'types': {'cached': 'bool'}}],
                                 'getClothObjectPtr': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet the nObject pointer for an nCloth',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'the pointer to the N cloth',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'MnCloth'},
                                                        'returnType': 'MnCloth',
                                                        'static': False,
                                                        'typeQualifiers': {'status': ['*']},
                                                        'types': {}}],
                                 'getCollide': [{'argInfo': {'collide': {'doc': 'the collision state',
                                                                         'type': 'bool'}},
                                                 'args': [('collide',
                                                           'bool',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet wether the nObject is allowed to participate in collisions',
                                                 'inArgs': [],
                                                 'outArgs': ['collide'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'collide': ['&']},
                                                 'types': {'collide': 'bool'}}],
                                 'getObjectPtr': [{'argInfo': {'ptr': {'doc': 'Storage to return the pointer to the N cloth.',
                                                                       'type': 'MnCloth'}},
                                                   'args': [('ptr',
                                                             'MnCloth',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                   'inArgs': [],
                                                   'inverse': ('setObjectPtr',
                                                               False),
                                                   'outArgs': ['ptr'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ptr': ['*&']},
                                                   'types': {'ptr': 'MnCloth'}},
                                                  {'argInfo': {'ptr': {'doc': 'Storage to return the pointer to the N rigid',
                                                                       'type': 'MnRigid'}},
                                                   'args': [('ptr',
                                                             'MnRigid',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                   'inArgs': [],
                                                   'inverse': ('setObjectPtr',
                                                               False),
                                                   'outArgs': ['ptr'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ptr': ['*&']},
                                                   'types': {'ptr': 'MnRigid'}},
                                                  {'argInfo': {'ptr': {'doc': 'Storage to return the pointer to the N particle.',
                                                                       'type': 'MnParticle'}},
                                                   'args': [('ptr',
                                                             'MnParticle',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                   'inArgs': [],
                                                   'inverse': ('setObjectPtr',
                                                               False),
                                                   'outArgs': ['ptr'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ptr': ['*&']},
                                                   'types': {'ptr': 'MnParticle'}}],
                                 'getParticleObjectPtr': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nGet the nObject pointer for an nParticle',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'the pointer to the N particle',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'MnParticle'},
                                                           'returnType': 'MnParticle',
                                                           'static': False,
                                                           'typeQualifiers': {'status': ['*']},
                                                           'types': {}}],
                                 'getRigidObjectPtr': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet the nObject pointer for an nRigid',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'the pointer to the N rigid',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'MnRigid'},
                                                        'returnType': 'MnRigid',
                                                        'static': False,
                                                        'typeQualifiers': {'status': ['*']},
                                                        'types': {}}],
                                 'isCached': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet whether the nObject is cached.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the cache state',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'status': ['*']},
                                               'types': {}}],
                                 'setCached': [{'argInfo': {'cached': {'doc': 'the cache state',
                                                                       'type': 'bool'}},
                                                'args': [('cached',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet wether the nObject is cached.',
                                                'inArgs': ['cached'],
                                                'inverse': ('getCached',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'cached': []},
                                                'types': {'cached': 'bool'}}],
                                 'setObjectPtr': [{'argInfo': {'ptr': {'doc': 'pointer to the N cloth',
                                                                       'type': 'MnCloth'}},
                                                   'args': [('ptr',
                                                             'MnCloth',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the nCloth pointer',
                                                   'inArgs': ['ptr'],
                                                   'inverse': ('getObjectPtr',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ptr': ['*']},
                                                   'types': {'ptr': 'MnCloth'}},
                                                  {'argInfo': {'ptr': {'doc': 'pointer to the nRigid',
                                                                       'type': 'MnRigid'}},
                                                   'args': [('ptr',
                                                             'MnRigid',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the nRigid pointer',
                                                   'inArgs': ['ptr'],
                                                   'inverse': ('getObjectPtr',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ptr': ['*']},
                                                   'types': {'ptr': 'MnRigid'}},
                                                  {'argInfo': {'ptr': {'doc': 'pointer to the nParticle',
                                                                       'type': 'MnParticle'}},
                                                   'args': [('ptr',
                                                             'MnParticle',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the nParticle pointer',
                                                   'inArgs': ['ptr'],
                                                   'inverse': ('getObjectPtr',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ptr': ['*']},
                                                   'types': {'ptr': 'MnParticle'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnNewtonField': {'enums': {},
                     'invertibles': [('setMinDistance', 'minDistance')],
                     'methods': {'minDistance': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the minimum distance from the newton field at which the force of the field is exerted.',
                                                  'inArgs': [],
                                                  'inverse': ('setMinDistance',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'A value representing distance in internal linear units.',
                                                                 'qualifiers': [],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'setMinDistance': [{'argInfo': {'distance': {'doc': 'A value representing distance in internal linear units.',
                                                                              'type': 'double'}},
                                                     'args': [('distance',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSets the minimum distance from the newton field at which the force of the field is exerted.',
                                                     'inArgs': ['distance'],
                                                     'inverse': ('minDistance',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'distance': []},
                                                     'types': {'distance': 'double'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'minDistance': 'getMinDistance'}},
  'MFnNonAmbientLight': {'enums': {},
                         'invertibles': [('setDecayRate', 'decayRate')],
                         'methods': {'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nClass name. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'decayRate': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRetrieves the value of the "decayRate" attribute of a non-ambient light node. This attribute determines the type of decay for the light.',
                                                    'inArgs': [],
                                                    'inverse': ('setDecayRate',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the "decayRate" attribute of the non-ambient light node.',
                                                                   'qualifiers': [],
                                                                   'type': 'short'},
                                                    'returnType': 'short',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                     'setDecayRate': [{'argInfo': {'decay_rate': {'doc': 'value to which the attribute will be set.',
                                                                                  'type': 'short'}},
                                                       'args': [('decay_rate',
                                                                 'short',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the value of the "decayRate" attribute of a non-ambient light node.',
                                                       'inArgs': ['decay_rate'],
                                                       'inverse': ('decayRate',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'decay_rate': ['const',
                                                                                         '&']},
                                                       'types': {'decay_rate': 'short'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFunction set type. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {},
                         'pymelMethods': {'decayRate': 'getDecayRate'}},
  'MFnNonExtendedLight': {'enums': {},
                          'invertibles': [('setCastSoftShadows',
                                           'castSoftShadows'),
                                          ('setDepthMapResolution',
                                           'depthMapResolution'),
                                          ('setDepthMapFocus',
                                           'depthMapFocus'),
                                          ('setUseDepthMapShadows',
                                           'useDepthMapShadows'),
                                          ('setDepthMapBias',
                                           'depthMapBias'),
                                          ('setShadowRadius',
                                           'shadowRadius'),
                                          ('setDepthMapFilterSize',
                                           'depthMapFilterSize'),
                                          ('setDepthMapWidthFocus',
                                           'depthMapWidthFocus'),
                                          ('setUseDepthMapAutoFocus',
                                           'useDepthMapAutoFocus')],
                          'methods': {'castSoftShadows': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nRetrieves the value of the "castSoftShadows" attribute of a non-extended light node. This attribute determines whether or not the light casts soft shadows.',
                                                           'inArgs': [],
                                                           'inverse': ('setCastSoftShadows',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The value of the "castSoftShadows" attribute of the non-extended light node.',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nClass name. \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'depthMapBias': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieves the value of the "depthMapBias" attribute of a light node. This attribute represents the depth bias applied in depth map shadow computations to prevent self-shadowing artifacts.',
                                                        'inArgs': [],
                                                        'inverse': ('setDepthMapBias',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "depthMapBias" attribute of the light node.',
                                                                       'qualifiers': [],
                                                                       'type': 'float'},
                                                        'returnType': 'float',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                      'depthMapFilterSize': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nRetrieves the value of the "depthMapFilterSize" attribute of a light node. This attribute determines the size of the filter used in depth map shadow computations for the light.',
                                                              'inArgs': [],
                                                              'inverse': ('setDepthMapFilterSize',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The value of the "depthMapFilterSize" attribute of the light node.',
                                                                             'qualifiers': [],
                                                                             'type': 'short'},
                                                              'returnType': 'short',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                      'depthMapFocus': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nRetrieves the value of the "depthMapFocus" attribute of a light node. This attribute represents the depth map\'s field of view.',
                                                         'inArgs': [],
                                                         'inverse': ('setDepthMapFocus',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The value of the "depthMapFocus" attribute of the light node.',
                                                                        'qualifiers': [],
                                                                        'type': 'float'},
                                                         'returnType': 'float',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                      'depthMapResolution': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nRetrieves the value of the "depthMapResolution" attribute of a light node. This attribute determines the resolution of the depth map for this light.',
                                                              'inArgs': [],
                                                              'inverse': ('setDepthMapResolution',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The value of the "depthMapResolution" attribute of the light node.',
                                                                             'qualifiers': [],
                                                                             'type': 'short'},
                                                              'returnType': 'short',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                      'depthMapWidthFocus': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nRetrieves the value of the "depthMapWidthFocus" attribute of a light node. This attribute is used to scale the depth map within the area of the light\'s illumination.',
                                                              'inArgs': [],
                                                              'inverse': ('setDepthMapWidthFocus',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The value of the "depthMapWidthFocus" attribute of the light node.',
                                                                             'qualifiers': [],
                                                                             'type': 'float'},
                                                              'returnType': 'float',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                      'setCastSoftShadows': [{'argInfo': {'cast_soft_shadows': {'doc': 'value to which the attribute will be set.',
                                                                                                'type': 'bool'}},
                                                              'args': [('cast_soft_shadows',
                                                                        'bool',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the value of the "castSoftShadows" attribute of a non-extended light node.',
                                                              'inArgs': ['cast_soft_shadows'],
                                                              'inverse': ('castSoftShadows',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'cast_soft_shadows': ['const',
                                                                                                       '&']},
                                                              'types': {'cast_soft_shadows': 'bool'}}],
                                      'setDepthMapBias': [{'argInfo': {'depth_map_bias': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'float'}},
                                                           'args': [('depth_map_bias',
                                                                     'float',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the value of the "depthMapBias" attribute of a light node.',
                                                           'inArgs': ['depth_map_bias'],
                                                           'inverse': ('depthMapBias',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'depth_map_bias': ['const',
                                                                                                 '&']},
                                                           'types': {'depth_map_bias': 'float'}}],
                                      'setDepthMapFilterSize': [{'argInfo': {'depth_map_filter_size': {'doc': 'value to which the attribute will be set.',
                                                                                                       'type': 'short'}},
                                                                 'args': [('depth_map_filter_size',
                                                                           'short',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the value of the "depthMapFilterSize" attribute of a light node.',
                                                                 'inArgs': ['depth_map_filter_size'],
                                                                 'inverse': ('depthMapFilterSize',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'depth_map_filter_size': ['const',
                                                                                                              '&']},
                                                                 'types': {'depth_map_filter_size': 'short'}}],
                                      'setDepthMapFocus': [{'argInfo': {'depth_map_focus': {'doc': 'value to which the attribute will be set.',
                                                                                            'type': 'float'}},
                                                            'args': [('depth_map_focus',
                                                                      'float',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSets the value of the "depthMapFocus" attribute of a light node.',
                                                            'inArgs': ['depth_map_focus'],
                                                            'inverse': ('depthMapFocus',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'depth_map_focus': ['const']},
                                                            'types': {'depth_map_focus': 'float'}}],
                                      'setDepthMapResolution': [{'argInfo': {'depth_map_resolution': {'doc': 'value to which the attribute will be set.',
                                                                                                      'type': 'short'}},
                                                                 'args': [('depth_map_resolution',
                                                                           'short',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the value of the "depthMapResolution" attribute of a light node.',
                                                                 'inArgs': ['depth_map_resolution'],
                                                                 'inverse': ('depthMapResolution',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'depth_map_resolution': ['const',
                                                                                                             '&']},
                                                                 'types': {'depth_map_resolution': 'short'}}],
                                      'setDepthMapWidthFocus': [{'argInfo': {'depth_map_width_focus': {'doc': 'value to which the attribute will be set.',
                                                                                                       'type': 'float'}},
                                                                 'args': [('depth_map_width_focus',
                                                                           'float',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the value of the "depthMapWidthFocus" attribute of a light node.',
                                                                 'inArgs': ['depth_map_width_focus'],
                                                                 'inverse': ('depthMapWidthFocus',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'depth_map_width_focus': ['const']},
                                                                 'types': {'depth_map_width_focus': 'float'}}],
                                      'setShadowRadius': [{'argInfo': {'shadow_radius': {'doc': 'value to which the attribute will be set.',
                                                                                         'type': 'float'}},
                                                           'args': [('shadow_radius',
                                                                     'float',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the value of the "shadowRadius" attribute of a non-extended light node.',
                                                           'inArgs': ['shadow_radius'],
                                                           'inverse': ('shadowRadius',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'shadow_radius': ['const',
                                                                                                '&']},
                                                           'types': {'shadow_radius': 'float'}}],
                                      'setUseDepthMapAutoFocus': [{'argInfo': {'use_depth_map_auto_focus': {'doc': 'value to which the attribute will be set.',
                                                                                                            'type': 'bool'}},
                                                                   'args': [('use_depth_map_auto_focus',
                                                                             'bool',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nSets the value of the "useDepthMapAutoFocus" attribute of a non-extended light node.',
                                                                   'inArgs': ['use_depth_map_auto_focus'],
                                                                   'inverse': ('useDepthMapAutoFocus',
                                                                               True),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'use_depth_map_auto_focus': ['const']},
                                                                   'types': {'use_depth_map_auto_focus': 'bool'}}],
                                      'setUseDepthMapShadows': [{'argInfo': {'use_depth_map': {'doc': 'value to which the attribute will be set.',
                                                                                               'type': 'bool'}},
                                                                 'args': [('use_depth_map',
                                                                           'bool',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the value of the "useDepthMapShadows" attribute of a non-extended light node.',
                                                                 'inArgs': ['use_depth_map'],
                                                                 'inverse': ('useDepthMapShadows',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'use_depth_map': ['const',
                                                                                                      '&']},
                                                                 'types': {'use_depth_map': 'bool'}}],
                                      'shadowRadius': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieves the value of the "shadowRadius" attribute of a non-extended light node. This attribute represents the radius of the light used when computing soft shadows. Higher radius values result in more extended soft shadows.',
                                                        'inArgs': [],
                                                        'inverse': ('setShadowRadius',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "shadowRadius" attribute of the non-extended light node.',
                                                                       'qualifiers': [],
                                                                       'type': 'float'},
                                                        'returnType': 'float',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nFunction set type. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                      'useDepthMapAutoFocus': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nRetrieves the value of the "useDepthMapAutoFocus" attribute of a non-extended light node. This attribute determines whether to automatically scale the depth map so that it only fills the area of the light\'s illumination that contains shadow casting objects.',
                                                                'inArgs': [],
                                                                'inverse': ('setUseDepthMapAutoFocus',
                                                                            False),
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'The value of the "useDepthMapAutoFocus" attribute of the non-extended light node.',
                                                                               'qualifiers': [],
                                                                               'type': 'bool'},
                                                                'returnType': 'bool',
                                                                'static': False,
                                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                                'types': {}}],
                                      'useDepthMapShadows': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nRetrieves the value of the "useDepthMapShadows" attribute of a non-extended light node. This attribute determines whether or not a depth map will be used in shadow computations for this light.',
                                                              'inArgs': [],
                                                              'inverse': ('setUseDepthMapShadows',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The value of the "useDepthMapShadows" attribute of the non-extended light node.',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'castSoftShadows': 'getCastSoftShadows',
                                           'depthMapBias': 'getDepthMapBias',
                                           'depthMapFilterSize': 'getDepthMapFilterSize',
                                           'depthMapFocus': 'getDepthMapFocus',
                                           'depthMapResolution': 'getDepthMapResolution',
                                           'depthMapWidthFocus': 'getDepthMapWidthFocus',
                                           'shadowRadius': 'getShadowRadius',
                                           'useDepthMapAutoFocus': 'getUseDepthMapAutoFocus',
                                           'useDepthMapShadows': 'getUseDepthMapShadows'}},
  'MFnNumericAttribute': {'enums': {},
                          'invertibles': [('setMin', 'getMin'),
                                          ('setMax', 'getMax'),
                                          ('setSoftMax', 'getSoftMax'),
                                          ('setDefault', 'getDefault'),
                                          ('setSoftMin', 'getSoftMin')],
                          'methods': {'child': [{'argInfo': {'index': {'doc': 'the full (or long) name of the attribute ',
                                                                       'type': 'uint'}},
                                                 'args': [('index',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the indicated child attribute as an  MObject . No index checking is done by this routine, so you must ensure that the index provided is valid.',
                                                 'inArgs': ['index'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'An MObject representing the child attribute ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'index': ['unsigned']},
                                                 'types': {'index': 'uint'}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nClass name. \r\n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'create': [{'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                        'type': 'MString'},
                                                              'defaultValue': {'doc': 'the default value for the new attribute ',
                                                                               'type': 'double'},
                                                              'full': {'doc': 'the full (or long) name of the attribute ',
                                                                       'type': 'MString'},
                                                              'unitType': {'doc': 'an element of the MFnUnitAttribute::Type enum ',
                                                                           'type': ('MFnNumericData',
                                                                                    'Type')}},
                                                  'args': [('full',
                                                            'MString',
                                                            'in'),
                                                           ('brief',
                                                            'MString',
                                                            'in'),
                                                           ('unitType',
                                                            ('MFnNumericData',
                                                             'Type'),
                                                            'in'),
                                                           ('defaultValue',
                                                            'double',
                                                            'in')],
                                                  'defaults': {'defaultValue': 0.0},
                                                  'deprecated': False,
                                                  'doc': '\r\nCreate a new numeric attribute and return it as an  MObject . If the attribute create is of a type that stores two or more values, then a compound attribute will be created. The names of child attributes will have "0", "1" and "2" appended to both the full and brief names. As well, each child will use the defaultValue parameter as its default.',
                                                  'inArgs': ['full',
                                                             'brief',
                                                             'unitType',
                                                             'defaultValue'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'brief': ['const',
                                                                               '&'],
                                                                     'defaultValue': [],
                                                                     'full': ['const',
                                                                              '&'],
                                                                     'unitType': []},
                                                  'types': {'brief': 'MString',
                                                            'defaultValue': 'double',
                                                            'full': 'MString',
                                                            'unitType': ('MFnNumericData',
                                                                         'Type')}},
                                                 {'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                        'type': 'MString'},
                                                              'child1': {'doc': 'a numeric attribute ',
                                                                         'type': 'MObject'},
                                                              'child2': {'doc': 'a numeric attribute ',
                                                                         'type': 'MObject'},
                                                              'child3': {'doc': 'a numeric attribute (optional) ',
                                                                         'type': 'MObject'},
                                                              'full': {'doc': 'the full (or long) name of the attribute ',
                                                                       'type': 'MString'}},
                                                  'args': [('full',
                                                            'MString',
                                                            'in'),
                                                           ('brief',
                                                            'MString',
                                                            'in'),
                                                           ('child1',
                                                            'MObject',
                                                            'in'),
                                                           ('child2',
                                                            'MObject',
                                                            'in'),
                                                           ('child3',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {'child3': 'MObject::kNullObj'},
                                                  'deprecated': False,
                                                  'doc': '\r\nCreate a new numeric attribute and return it as an  MObject . This form of the create method allows the creation of a compound attribute having two or three numeric child attributes. All of the child attributes must be of the same type (eg all of type kDouble) and must already have been created but not yet added to the node.',
                                                  'inArgs': ['full',
                                                             'brief',
                                                             'child1',
                                                             'child2',
                                                             'child3'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'brief': ['const',
                                                                               '&'],
                                                                     'child1': ['const',
                                                                                '&'],
                                                                     'child2': ['const',
                                                                                '&'],
                                                                     'child3': ['const',
                                                                                '&'],
                                                                     'full': ['const',
                                                                              '&']},
                                                  'types': {'brief': 'MString',
                                                            'child1': 'MObject',
                                                            'child2': 'MObject',
                                                            'child3': 'MObject',
                                                            'full': 'MString'}}],
                                      'createAddr': [{'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                            'type': 'MString'},
                                                                  'defaultValue': {'doc': 'the default value for the new attribute ',
                                                                                   'type': 'void'},
                                                                  'full': {'doc': 'the full (or long) name of the attribute ',
                                                                           'type': 'MString'}},
                                                      'args': [('full',
                                                                'MString',
                                                                'in'),
                                                               ('brief',
                                                                'MString',
                                                                'in'),
                                                               ('defaultValue',
                                                                'void',
                                                                'in')],
                                                      'defaults': {'defaultValue': None},
                                                      'deprecated': False,
                                                      'doc': '\r\nCreate a new address attribute and return it as an  MObject .',
                                                      'inArgs': ['full',
                                                                 'brief',
                                                                 'defaultValue'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'brief': ['const',
                                                                                   '&'],
                                                                         'defaultValue': ['*'],
                                                                         'full': ['const',
                                                                                  '&']},
                                                      'types': {'brief': 'MString',
                                                                'defaultValue': 'void',
                                                                'full': 'MString'}}],
                                      'createColor': [{'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                             'type': 'MString'},
                                                                   'full': {'doc': 'the full (or long) name of the attribute ',
                                                                            'type': 'MString'}},
                                                       'args': [('full',
                                                                 'MString',
                                                                 'in'),
                                                                ('brief',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nCreate a new color attribute and return it as an  MObject . The names of child attributes will have "r", "g" and "b" appended to both the full and brief names.',
                                                       'inArgs': ['full',
                                                                  'brief'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                                      'qualifiers': [],
                                                                      'type': 'MObject'},
                                                       'returnType': 'MObject',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'brief': ['const',
                                                                                    '&'],
                                                                          'full': ['const',
                                                                                   '&']},
                                                       'types': {'brief': 'MString',
                                                                 'full': 'MString'}}],
                                      'createPoint': [{'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                             'type': 'MString'},
                                                                   'full': {'doc': 'the full (or long) name of the attribute ',
                                                                            'type': 'MString'}},
                                                       'args': [('full',
                                                                 'MString',
                                                                 'in'),
                                                                ('brief',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nCreate a new point attribute and return it as an  MObject . The names of child attributes will have "x", "y" and "z" appended to both the full and brief names.',
                                                       'inArgs': ['full',
                                                                  'brief'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                                      'qualifiers': [],
                                                                      'type': 'MObject'},
                                                       'returnType': 'MObject',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'brief': ['const',
                                                                                    '&'],
                                                                          'full': ['const',
                                                                                   '&']},
                                                       'types': {'brief': 'MString',
                                                                 'full': 'MString'}}],
                                      'getDefault': [{'argInfo': {'def1': {'doc': 'returns the default value for this attribute',
                                                                           'type': 'bool'}},
                                                      'args': [('def1',
                                                                'bool',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the default value for this boolean attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&']},
                                                      'types': {'def1': 'bool'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for this attribute',
                                                                           'type': 'char'}},
                                                      'args': [('def1',
                                                                'char',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the default value for this character attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&']},
                                                      'types': {'def1': 'char'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for this attribute',
                                                                           'type': 'int'}},
                                                      'args': [('def1',
                                                                'int',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for this integral attribute. This method can be used to get default values for attributes of type  byte ,  short  or  int .',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&']},
                                                      'types': {'def1': 'int'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for first child of this attribute ',
                                                                           'type': 'int'},
                                                                  'def2': {'doc': 'returns the default value for second child of this attribute',
                                                                           'type': 'int'}},
                                                      'args': [('def1',
                                                                'int',
                                                                'out'),
                                                               ('def2',
                                                                'int',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for the integral attributes of the two children of this attribute. This method is used to query the default values for attributes of type  byte ,  short  or  int .',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1',
                                                                  'def2'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&'],
                                                                         'def2': ['&']},
                                                      'types': {'def1': 'int',
                                                                'def2': 'int'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for first child of this attribute ',
                                                                           'type': 'int'},
                                                                  'def2': {'doc': 'returns the default value for second child of this attribute ',
                                                                           'type': 'int'},
                                                                  'def3': {'doc': 'returns the default value for third child of this attribute',
                                                                           'type': 'int'}},
                                                      'args': [('def1',
                                                                'int',
                                                                'out'),
                                                               ('def2',
                                                                'int',
                                                                'out'),
                                                               ('def3',
                                                                'int',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for the integral attributes of the three children of this attribute. This method is used to get the default values for attributes of type  byte ,  short  or  int .',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1',
                                                                  'def2',
                                                                  'def3'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&'],
                                                                         'def2': ['&'],
                                                                         'def3': ['&']},
                                                      'types': {'def1': 'int',
                                                                'def2': 'int',
                                                                'def3': 'int'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for this attribute',
                                                                           'type': 'MInt64'}},
                                                      'args': [('def1',
                                                                'MInt64',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for this integral attribute and returns it as a 64-bit int. This method can be used to get default values for attributes of type  byte ,  short ,  int  or  MInt64 .',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&']},
                                                      'types': {'def1': 'MInt64'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for this attribute',
                                                                           'type': 'float'}},
                                                      'args': [('def1',
                                                                'float',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for this float attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&']},
                                                      'types': {'def1': 'float'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for first child of this attribute ',
                                                                           'type': 'float'},
                                                                  'def2': {'doc': 'returns the default value for second child of this attribute',
                                                                           'type': 'float'}},
                                                      'args': [('def1',
                                                                'float',
                                                                'out'),
                                                               ('def2',
                                                                'float',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for the float attributes of the two children of this attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1',
                                                                  'def2'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&'],
                                                                         'def2': ['&']},
                                                      'types': {'def1': 'float',
                                                                'def2': 'float'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for first child of this attribute ',
                                                                           'type': 'float'},
                                                                  'def2': {'doc': 'returns the default value for second child of this attribute ',
                                                                           'type': 'float'},
                                                                  'def3': {'doc': 'returns the default value for third child of this attribute',
                                                                           'type': 'float'}},
                                                      'args': [('def1',
                                                                'float',
                                                                'out'),
                                                               ('def2',
                                                                'float',
                                                                'out'),
                                                               ('def3',
                                                                'float',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for the float attributes of the three children of this attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1',
                                                                  'def2',
                                                                  'def3'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&'],
                                                                         'def2': ['&'],
                                                                         'def3': ['&']},
                                                      'types': {'def1': 'float',
                                                                'def2': 'float',
                                                                'def3': 'float'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the default value for this double attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&']},
                                                      'types': {'def1': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for first child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def2': {'doc': 'returns the default value for second child of this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'out'),
                                                               ('def2',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for the double attributes of the two children of this attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1',
                                                                  'def2'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&'],
                                                                         'def2': ['&']},
                                                      'types': {'def1': 'double',
                                                                'def2': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for first child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def2': {'doc': 'returns the default value for second child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def3': {'doc': 'returns the default value for third child of this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'out'),
                                                               ('def2',
                                                                'double',
                                                                'out'),
                                                               ('def3',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for the double attributes of the three children of this attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1',
                                                                  'def2',
                                                                  'def3'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&'],
                                                                         'def2': ['&'],
                                                                         'def3': ['&']},
                                                      'types': {'def1': 'double',
                                                                'def2': 'double',
                                                                'def3': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for first child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def2': {'doc': 'returns the default value for second child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def3': {'doc': 'returns the default value for third child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def4': {'doc': 'returns the default value for fourth child of this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'out'),
                                                               ('def2',
                                                                'double',
                                                                'out'),
                                                               ('def3',
                                                                'double',
                                                                'out'),
                                                               ('def4',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGets the default value for the double attributes of the four children of this attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1',
                                                                  'def2',
                                                                  'def3',
                                                                  'def4'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['&'],
                                                                         'def2': ['&'],
                                                                         'def3': ['&'],
                                                                         'def4': ['&']},
                                                      'types': {'def1': 'double',
                                                                'def2': 'double',
                                                                'def3': 'double',
                                                                'def4': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'returns the default value for this attribute',
                                                                           'type': 'void'}},
                                                      'args': [('def1',
                                                                'void',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the default value for this address attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setDefault',
                                                                  False),
                                                      'outArgs': ['def1'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['*&']},
                                                      'types': {'def1': 'void'}}],
                                      'getMax': [{'argInfo': {'max': {'doc': 'the maximum value for this attribute',
                                                                      'type': 'double'}},
                                                  'args': [('max',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the maximum value for this double attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMax',
                                                              False),
                                                  'outArgs': ['max'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'max': ['&']},
                                                  'types': {'max': 'double'}},
                                                 {'argInfo': {'max1': {'doc': 'the maximum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'max2': {'doc': 'the maximum value for the second child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('max1',
                                                            'double',
                                                            'out'),
                                                           ('max2',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the maximum values for the two children (both double attributes) of this compound attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMax',
                                                              False),
                                                  'outArgs': ['max1',
                                                              'max2'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'max1': ['&'],
                                                                     'max2': ['&']},
                                                  'types': {'max1': 'double',
                                                            'max2': 'double'}},
                                                 {'argInfo': {'max1': {'doc': 'the maximum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'max2': {'doc': 'the maximum value for the second child attribute ',
                                                                       'type': 'double'},
                                                              'max3': {'doc': 'the maximum value for the third child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('max1',
                                                            'double',
                                                            'out'),
                                                           ('max2',
                                                            'double',
                                                            'out'),
                                                           ('max3',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the maximum values for the three children (all double attributes) of this compound attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMax',
                                                              False),
                                                  'outArgs': ['max1',
                                                              'max2',
                                                              'max3'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'max1': ['&'],
                                                                     'max2': ['&'],
                                                                     'max3': ['&']},
                                                  'types': {'max1': 'double',
                                                            'max2': 'double',
                                                            'max3': 'double'}}],
                                      'getMin': [{'argInfo': {'min': {'doc': 'the minimum value for this attribute',
                                                                      'type': 'double'}},
                                                  'args': [('min',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the minimum value for this double attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMin',
                                                              False),
                                                  'outArgs': ['min'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'min': ['&']},
                                                  'types': {'min': 'double'}},
                                                 {'argInfo': {'min1': {'doc': 'the minimum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'min2': {'doc': 'the minimum value for the second child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('min1',
                                                            'double',
                                                            'out'),
                                                           ('min2',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the minimum values for the two children (both double attributes) of this compound attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMin',
                                                              False),
                                                  'outArgs': ['min1',
                                                              'min2'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'min1': ['&'],
                                                                     'min2': ['&']},
                                                  'types': {'min1': 'double',
                                                            'min2': 'double'}},
                                                 {'argInfo': {'min1': {'doc': 'the minimum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'min2': {'doc': 'the minimum value for the second child attribute ',
                                                                       'type': 'double'},
                                                              'min3': {'doc': 'the minimum value for the third child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('min1',
                                                            'double',
                                                            'out'),
                                                           ('min2',
                                                            'double',
                                                            'out'),
                                                           ('min3',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the minimum values for the three children (all double attributes) of this compound attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMin',
                                                              False),
                                                  'outArgs': ['min1',
                                                              'min2',
                                                              'min3'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'min1': ['&'],
                                                                     'min2': ['&'],
                                                                     'min3': ['&']},
                                                  'types': {'min1': 'double',
                                                            'min2': 'double',
                                                            'min3': 'double'}}],
                                      'getSoftMax': [{'argInfo': {'max': {'doc': 'the soft maximum value for this attribute',
                                                                          'type': 'double'}},
                                                      'args': [('max',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn the maximum value for this double attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setSoftMax',
                                                                  False),
                                                      'outArgs': ['max'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'max': ['&']},
                                                      'types': {'max': 'double'}}],
                                      'getSoftMin': [{'argInfo': {'min': {'doc': 'the minimum value for this attribute',
                                                                          'type': 'double'}},
                                                      'args': [('min',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn the minimum value for this double attribute.',
                                                      'inArgs': [],
                                                      'inverse': ('setSoftMin',
                                                                  False),
                                                      'outArgs': ['min'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'min': ['&']},
                                                      'types': {'min': 'double'}}],
                                      'hasMax': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermine whether or not this attribute has a maximum value set.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the attribute has a maximum value, and false otherwise ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                      'hasMin': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermine whether or not this attribute has a minimum value set.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the attribute has a minimum value, and false otherwise ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                      'hasSoftMax': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nDetermine whether or not this double attribute has a soft maximum value set.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'true if the attribute has a soft maximum value, and false otherwise ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                      'hasSoftMin': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nDetermine whether or not this double attribute has a soft minimum value set.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'true if the attribute has a soft minimum value, and false otherwise ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                      'setDefault': [{'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'bool'}},
                                                      'args': [('def1',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for this boolean attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': []},
                                                      'types': {'def1': 'bool'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'char'}},
                                                      'args': [('def1',
                                                                'char',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for this character attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': []},
                                                      'types': {'def1': 'char'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'int'}},
                                                      'args': [('def1',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for this integral attribute. This method can be used to set default values for  byte ,  short  or  int  attributes.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': []},
                                                      'types': {'def1': 'int'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for first child of this attribute ',
                                                                           'type': 'int'},
                                                                  'def2': {'doc': 'new the default value for second child of this attribute',
                                                                           'type': 'int'}},
                                                      'args': [('def1',
                                                                'int',
                                                                'in'),
                                                               ('def2',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for the integral attributes of the two children of this attribute. This method is used to set default values for  byte ,  short  or  int  attributes.',
                                                      'inArgs': ['def1',
                                                                 'def2'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': [],
                                                                         'def2': []},
                                                      'types': {'def1': 'int',
                                                                'def2': 'int'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for first child of this attribute ',
                                                                           'type': 'int'},
                                                                  'def2': {'doc': 'new the default value for second child of this attribute ',
                                                                           'type': 'int'},
                                                                  'def3': {'doc': 'new the default value for third child of this attribute',
                                                                           'type': 'int'}},
                                                      'args': [('def1',
                                                                'int',
                                                                'in'),
                                                               ('def2',
                                                                'int',
                                                                'in'),
                                                               ('def3',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for the integral attributes of the three children of this attribute. This method is used to set default values for  byte ,  short  or  int  attributes.',
                                                      'inArgs': ['def1',
                                                                 'def2',
                                                                 'def3'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': [],
                                                                         'def2': [],
                                                                         'def3': []},
                                                      'types': {'def1': 'int',
                                                                'def2': 'int',
                                                                'def3': 'int'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'MInt64'}},
                                                      'args': [('def1',
                                                                'MInt64',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for this integral attribute. This method can be used to set default values for  byte ,  short ,  int  or  MInt64  attributes.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': []},
                                                      'types': {'def1': 'MInt64'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'float'}},
                                                      'args': [('def1',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for this float attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': []},
                                                      'types': {'def1': 'float'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for first child of this attribute ',
                                                                           'type': 'float'},
                                                                  'def2': {'doc': 'new the default value for second child of this attribute',
                                                                           'type': 'float'}},
                                                      'args': [('def1',
                                                                'float',
                                                                'in'),
                                                               ('def2',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for the float attributes of the two children of this attribute.',
                                                      'inArgs': ['def1',
                                                                 'def2'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': [],
                                                                         'def2': []},
                                                      'types': {'def1': 'float',
                                                                'def2': 'float'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for first child of this attribute ',
                                                                           'type': 'float'},
                                                                  'def2': {'doc': 'new the default value for second child of this attribute ',
                                                                           'type': 'float'},
                                                                  'def3': {'doc': 'new the default value for third child of this attribute',
                                                                           'type': 'float'}},
                                                      'args': [('def1',
                                                                'float',
                                                                'in'),
                                                               ('def2',
                                                                'float',
                                                                'in'),
                                                               ('def3',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for the float attributes of the three children of this attribute.',
                                                      'inArgs': ['def1',
                                                                 'def2',
                                                                 'def3'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': [],
                                                                         'def2': [],
                                                                         'def3': []},
                                                      'types': {'def1': 'float',
                                                                'def2': 'float',
                                                                'def3': 'float'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for this double attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': []},
                                                      'types': {'def1': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for first child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def2': {'doc': 'new the default value for second child of this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'in'),
                                                               ('def2',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for the double attributes of the two children of this attribute.',
                                                      'inArgs': ['def1',
                                                                 'def2'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': [],
                                                                         'def2': []},
                                                      'types': {'def1': 'double',
                                                                'def2': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for first child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def2': {'doc': 'new the default value for second child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def3': {'doc': 'new the default value for third child of this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'in'),
                                                               ('def2',
                                                                'double',
                                                                'in'),
                                                               ('def3',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for the double attributes of the three children of this attribute.',
                                                      'inArgs': ['def1',
                                                                 'def2',
                                                                 'def3'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': [],
                                                                         'def2': [],
                                                                         'def3': []},
                                                      'types': {'def1': 'double',
                                                                'def2': 'double',
                                                                'def3': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for first child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def2': {'doc': 'new the default value for second child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def3': {'doc': 'new the default value for third child of this attribute ',
                                                                           'type': 'double'},
                                                                  'def4': {'doc': 'new the default value for fourth child of this attribute',
                                                                           'type': 'double'}},
                                                      'args': [('def1',
                                                                'double',
                                                                'in'),
                                                               ('def2',
                                                                'double',
                                                                'in'),
                                                               ('def3',
                                                                'double',
                                                                'in'),
                                                               ('def4',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for the double attributes of the four children of this attribute.',
                                                      'inArgs': ['def1',
                                                                 'def2',
                                                                 'def3',
                                                                 'def4'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': [],
                                                                         'def2': [],
                                                                         'def3': [],
                                                                         'def4': []},
                                                      'types': {'def1': 'double',
                                                                'def2': 'double',
                                                                'def3': 'double',
                                                                'def4': 'double'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'void'}},
                                                      'args': [('def1',
                                                                'void',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet a new default value for this address attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'def1': ['*']},
                                                      'types': {'def1': 'void'}}],
                                      'setMax': [{'argInfo': {'max': {'doc': 'the maximum value for this attribute',
                                                                      'type': 'double'}},
                                                  'args': [('max',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the maximum value for this double attribute.',
                                                  'inArgs': ['max'],
                                                  'inverse': ('getMax',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'max': []},
                                                  'types': {'max': 'double'}},
                                                 {'argInfo': {'max1': {'doc': 'the maximum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'max2': {'doc': 'the maximum value for the second child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('max1',
                                                            'double',
                                                            'in'),
                                                           ('max2',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the maximum values for the two children (both double attributes) of this compound attribute.',
                                                  'inArgs': ['max1',
                                                             'max2'],
                                                  'inverse': ('getMax',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'max1': [],
                                                                     'max2': []},
                                                  'types': {'max1': 'double',
                                                            'max2': 'double'}},
                                                 {'argInfo': {'max1': {'doc': 'the maximum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'max2': {'doc': 'the maximum value for the second child attribute ',
                                                                       'type': 'double'},
                                                              'max3': {'doc': 'the maximum value for the third child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('max1',
                                                            'double',
                                                            'in'),
                                                           ('max2',
                                                            'double',
                                                            'in'),
                                                           ('max3',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the maximum values for the three children (all double attributes) of this compound attribute.',
                                                  'inArgs': ['max1',
                                                             'max2',
                                                             'max3'],
                                                  'inverse': ('getMax',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'max1': [],
                                                                     'max2': [],
                                                                     'max3': []},
                                                  'types': {'max1': 'double',
                                                            'max2': 'double',
                                                            'max3': 'double'}}],
                                      'setMin': [{'argInfo': {'min': {'doc': 'the minimum value for this attribute',
                                                                      'type': 'double'}},
                                                  'args': [('min',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the minimum value for this double attribute.',
                                                  'inArgs': ['min'],
                                                  'inverse': ('getMin',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'min': []},
                                                  'types': {'min': 'double'}},
                                                 {'argInfo': {'min1': {'doc': 'the minimum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'min2': {'doc': 'the minimum value for the second child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('min1',
                                                            'double',
                                                            'in'),
                                                           ('min2',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the minimum values for the two children (both double attributes) of this compound attribute.',
                                                  'inArgs': ['min1',
                                                             'min2'],
                                                  'inverse': ('getMin',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'min1': [],
                                                                     'min2': []},
                                                  'types': {'min1': 'double',
                                                            'min2': 'double'}},
                                                 {'argInfo': {'min1': {'doc': 'the minimum value for the first child attribute ',
                                                                       'type': 'double'},
                                                              'min2': {'doc': 'the minimum value for the second child attribute ',
                                                                       'type': 'double'},
                                                              'min3': {'doc': 'the minimum value for the third child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('min1',
                                                            'double',
                                                            'in'),
                                                           ('min2',
                                                            'double',
                                                            'in'),
                                                           ('min3',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the minimum values for the three children (all double attributes) of this compound attribute.',
                                                  'inArgs': ['min1',
                                                             'min2',
                                                             'min3'],
                                                  'inverse': ('getMin',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'min1': [],
                                                                     'min2': [],
                                                                     'min3': []},
                                                  'types': {'min1': 'double',
                                                            'min2': 'double',
                                                            'min3': 'double'}}],
                                      'setSoftMax': [{'argInfo': {'max': {'doc': 'the soft maximum value for this attribute',
                                                                          'type': 'double'}},
                                                      'args': [('max',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the soft maximum value for this double attribute.',
                                                      'inArgs': ['max'],
                                                      'inverse': ('getSoftMax',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'max': []},
                                                      'types': {'max': 'double'}}],
                                      'setSoftMin': [{'argInfo': {'min': {'doc': 'the minimum value for this attribute',
                                                                          'type': 'double'}},
                                                      'args': [('min',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the soft minimum value for this double attribute.',
                                                      'inArgs': ['min'],
                                                      'inverse': ('getSoftMin',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'min': []},
                                                      'types': {'min': 'double'}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nFunction set type. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                      'unitType': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the unit type of this attribute.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'An element of the MFnNumericData::Type enum ',
                                                                   'qualifiers': [],
                                                                   'type': ('MFnNumericData',
                                                                            'Type')},
                                                    'returnType': ('MFnNumericData',
                                                                   'Type'),
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}]},
                          'pymelEnums': {}},
  'MFnNumericData': {'enums': {'Type': {'valueDocs': {'addr': 'An address.',
                                                      'boolean': 'Boolean.',
                                                      'byte': 'One byte.',
                                                      'char': 'One character.',
                                                      'double': 'One double.',
                                                      'float': 'One float.',
                                                      'int': 'One int.',
                                                      'int64': 'One 64-bit int.',
                                                      'invalid': 'Invalid data.',
                                                      'k2Double': 'Two doubles.',
                                                      'k2Float': 'Two floats.',
                                                      'k2Int': 'Two ints.',
                                                      'k2Long': 'Two longs. Same as 2 ints since "long" is not platform-consistent.',
                                                      'k2Short': 'Two shorts.',
                                                      'k3Double': 'Three doubles.',
                                                      'k3Float': 'Three floats.',
                                                      'k3Int': 'Three ints.',
                                                      'k3Long': 'Three longs. Same as 3 ints since "long" is not platform-consistent.',
                                                      'k3Short': 'Three shorts.',
                                                      'k4Double': 'Four doubles.',
                                                      'kAddr': 'An address.',
                                                      'kBoolean': 'Boolean.',
                                                      'kByte': 'One byte.',
                                                      'kChar': 'One character.',
                                                      'kDouble': 'One double.',
                                                      'kFloat': 'One float.',
                                                      'kInt': 'One int.',
                                                      'kInt64': 'One 64-bit int.',
                                                      'kInvalid': 'Invalid data.',
                                                      'kLast': 'Last value. Does not represent a real type, but can be used to loop on all possible types.',
                                                      'kLong': 'One long. Same as int since "long" is not platform-consistent.',
                                                      'kShort': 'One short.',
                                                      'last': 'Last value. Does not represent a real type, but can be used to loop on all possible types.',
                                                      'long': 'One long. Same as int since "long" is not platform-consistent.',
                                                      'short': 'One short.'},
                                        'values': "Enum('Type', [('kInvalid', 0), ('kBoolean', 1), ('kByte', 2), ('kChar', 3), ('kShort', 4), ('k2Short', 5), ('k3Short', 6), ('kLong', 7), ('kInt', 7), ('k2Int', 8), ('k2Long', 8), ('k3Long', 9), ('k3Int', 9), ('kInt64', 10), ('kFloat', 11), ('k2Float', 12), ('k3Float', 13), ('kDouble', 14), ('k2Double', 15), ('k3Double', 16), ('k4Double', 17), ('kAddr', 18), ('kLast', 19)], multiKeys=True)"}},
                     'invertibles': [('setData4Double', 'getData4Double'),
                                     ('setData2Int', 'getData2Int'),
                                     ('setData3Float', 'getData3Float'),
                                     ('setData2Float', 'getData2Float'),
                                     ('setData2Double', 'getData2Double'),
                                     ('setData3Int', 'getData3Int'),
                                     ('setData3Double', 'getData3Double'),
                                     ('setData3Short', 'getData3Short'),
                                     ('setData2Short', 'getData2Short'),
                                     ('setData', 'getData')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClass name. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {'dataType': {'doc': 'data type of object to create ',
                                                                      'type': ('MFnNumericData',
                                                                               'Type')}},
                                             'args': [('dataType',
                                                       ('MFnNumericData',
                                                        'Type'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCreates a new data object of the given type. Only pair and triples of numeric data may be created (eg k3Float).',
                                             'inArgs': ['dataType'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A pointer to the new object',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'dataType': []},
                                             'types': {'dataType': ('MFnNumericData',
                                                                    'Type')}}],
                                 'getData': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'short'},
                                                          'val2': {'doc': 'storage for the second element',
                                                                   'type': 'short'}},
                                              'args': [('val1',
                                                        'short',
                                                        'out'),
                                                       ('val2',
                                                        'short',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1', 'val2'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&']},
                                              'types': {'val1': 'short',
                                                        'val2': 'short'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'int'},
                                                          'val2': {'doc': 'storage for the second element',
                                                                   'type': 'int'}},
                                              'args': [('val1',
                                                        'int',
                                                        'out'),
                                                       ('val2',
                                                        'int',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1', 'val2'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&']},
                                              'types': {'val1': 'int',
                                                        'val2': 'int'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'float'},
                                                          'val2': {'doc': 'storage for the second element',
                                                                   'type': 'float'}},
                                              'args': [('val1',
                                                        'float',
                                                        'out'),
                                                       ('val2',
                                                        'float',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1', 'val2'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&']},
                                              'types': {'val1': 'float',
                                                        'val2': 'float'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'storage for the second element',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'out'),
                                                       ('val2',
                                                        'double',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1', 'val2'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&']},
                                              'types': {'val1': 'double',
                                                        'val2': 'double'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'short'},
                                                          'val2': {'doc': 'storage for the second element ',
                                                                   'type': 'short'},
                                                          'val3': {'doc': 'storage for the third element',
                                                                   'type': 'short'}},
                                              'args': [('val1',
                                                        'short',
                                                        'out'),
                                                       ('val2',
                                                        'short',
                                                        'out'),
                                                       ('val3',
                                                        'short',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1',
                                                          'val2',
                                                          'val3'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&'],
                                                                 'val3': ['&']},
                                              'types': {'val1': 'short',
                                                        'val2': 'short',
                                                        'val3': 'short'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'int'},
                                                          'val2': {'doc': 'storage for the second element ',
                                                                   'type': 'int'},
                                                          'val3': {'doc': 'storage for the third element',
                                                                   'type': 'int'}},
                                              'args': [('val1',
                                                        'int',
                                                        'out'),
                                                       ('val2',
                                                        'int',
                                                        'out'),
                                                       ('val3',
                                                        'int',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1',
                                                          'val2',
                                                          'val3'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&'],
                                                                 'val3': ['&']},
                                              'types': {'val1': 'int',
                                                        'val2': 'int',
                                                        'val3': 'int'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'float'},
                                                          'val2': {'doc': 'storage for the second element ',
                                                                   'type': 'float'},
                                                          'val3': {'doc': 'storage for the third element',
                                                                   'type': 'float'}},
                                              'args': [('val1',
                                                        'float',
                                                        'out'),
                                                       ('val2',
                                                        'float',
                                                        'out'),
                                                       ('val3',
                                                        'float',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1',
                                                          'val2',
                                                          'val3'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&'],
                                                                 'val3': ['&']},
                                              'types': {'val1': 'float',
                                                        'val2': 'float',
                                                        'val3': 'float'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'storage for the second element ',
                                                                   'type': 'double'},
                                                          'val3': {'doc': 'storage for the third element',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'out'),
                                                       ('val2',
                                                        'double',
                                                        'out'),
                                                       ('val3',
                                                        'double',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1',
                                                          'val2',
                                                          'val3'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&'],
                                                                 'val3': ['&']},
                                              'types': {'val1': 'double',
                                                        'val2': 'double',
                                                        'val3': 'double'}},
                                             {'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'storage for the second element ',
                                                                   'type': 'double'},
                                                          'val3': {'doc': 'storage for the third element ',
                                                                   'type': 'double'},
                                                          'val4': {'doc': 'storage for the fourth element',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'out'),
                                                       ('val2',
                                                        'double',
                                                        'out'),
                                                       ('val3',
                                                        'double',
                                                        'out'),
                                                       ('val4',
                                                        'double',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': [],
                                              'inverse': ('setData',
                                                          False),
                                              'outArgs': ['val1',
                                                          'val2',
                                                          'val3',
                                                          'val4'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': ['&'],
                                                                 'val2': ['&'],
                                                                 'val3': ['&'],
                                                                 'val4': ['&']},
                                              'types': {'val1': 'double',
                                                        'val2': 'double',
                                                        'val3': 'double',
                                                        'val4': 'double'}}],
                                 'getData2Double': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                          'type': 'double'},
                                                                 'val2': {'doc': 'storage for the second element',
                                                                          'type': 'double'}},
                                                     'args': [('val1',
                                                               'double',
                                                               'out'),
                                                              ('val2',
                                                               'double',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the stored value of this data object as a pair of doubles. The data object must have been created as a pair of doubles for this to succeed.',
                                                     'inArgs': [],
                                                     'inverse': ('setData2Double',
                                                                 False),
                                                     'outArgs': ['val1',
                                                                 'val2'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'val1': ['&'],
                                                                        'val2': ['&']},
                                                     'types': {'val1': 'double',
                                                               'val2': 'double'}}],
                                 'getData2Float': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                         'type': 'float'},
                                                                'val2': {'doc': 'storage for the second element',
                                                                         'type': 'float'}},
                                                    'args': [('val1',
                                                              'float',
                                                              'out'),
                                                             ('val2',
                                                              'float',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGets the stored value of this data object as a pair of floats. The data object must have been created as a pair of floats for this to succeed.',
                                                    'inArgs': [],
                                                    'inverse': ('setData2Float',
                                                                False),
                                                    'outArgs': ['val1',
                                                                'val2'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': ['&'],
                                                                       'val2': ['&']},
                                                    'types': {'val1': 'float',
                                                              'val2': 'float'}}],
                                 'getData2Int': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                       'type': 'int'},
                                                              'val2': {'doc': 'storage for the second element',
                                                                       'type': 'int'}},
                                                  'args': [('val1',
                                                            'int',
                                                            'out'),
                                                           ('val2',
                                                            'int',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGets the stored value of this data object as a pair of int integers. The data object must have been created as a pair of int integers for this to succeed.',
                                                  'inArgs': [],
                                                  'inverse': ('setData2Int',
                                                              False),
                                                  'outArgs': ['val1',
                                                              'val2'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'val1': ['&'],
                                                                     'val2': ['&']},
                                                  'types': {'val1': 'int',
                                                            'val2': 'int'}}],
                                 'getData2Short': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                         'type': 'short'},
                                                                'val2': {'doc': 'storage for the second element',
                                                                         'type': 'short'}},
                                                    'args': [('val1',
                                                              'short',
                                                              'out'),
                                                             ('val2',
                                                              'short',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGets the stored value of this data object as a pair of short integers. The data object must have been created as a pair of short integers for this to succeed.',
                                                    'inArgs': [],
                                                    'inverse': ('setData2Short',
                                                                False),
                                                    'outArgs': ['val1',
                                                                'val2'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': ['&'],
                                                                       'val2': ['&']},
                                                    'types': {'val1': 'short',
                                                              'val2': 'short'}}],
                                 'getData3Double': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                          'type': 'double'},
                                                                 'val2': {'doc': 'storage for the second element ',
                                                                          'type': 'double'},
                                                                 'val3': {'doc': 'storage for the third element',
                                                                          'type': 'double'}},
                                                     'args': [('val1',
                                                               'double',
                                                               'out'),
                                                              ('val2',
                                                               'double',
                                                               'out'),
                                                              ('val3',
                                                               'double',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the stored value of this data object as a triple of doubles. The data object must have been created as a triple of doubles for this to succeed.',
                                                     'inArgs': [],
                                                     'inverse': ('setData3Double',
                                                                 False),
                                                     'outArgs': ['val1',
                                                                 'val2',
                                                                 'val3'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'val1': ['&'],
                                                                        'val2': ['&'],
                                                                        'val3': ['&']},
                                                     'types': {'val1': 'double',
                                                               'val2': 'double',
                                                               'val3': 'double'}}],
                                 'getData3Float': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                         'type': 'float'},
                                                                'val2': {'doc': 'storage for the second element ',
                                                                         'type': 'float'},
                                                                'val3': {'doc': 'storage for the third element',
                                                                         'type': 'float'}},
                                                    'args': [('val1',
                                                              'float',
                                                              'out'),
                                                             ('val2',
                                                              'float',
                                                              'out'),
                                                             ('val3',
                                                              'float',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGets the stored value of this data object as a triple of floats. The data object must have been created as a triple of floats for this to succeed.',
                                                    'inArgs': [],
                                                    'inverse': ('setData3Float',
                                                                False),
                                                    'outArgs': ['val1',
                                                                'val2',
                                                                'val3'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': ['&'],
                                                                       'val2': ['&'],
                                                                       'val3': ['&']},
                                                    'types': {'val1': 'float',
                                                              'val2': 'float',
                                                              'val3': 'float'}}],
                                 'getData3Int': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                       'type': 'int'},
                                                              'val2': {'doc': 'storage for the second element ',
                                                                       'type': 'int'},
                                                              'val3': {'doc': 'storage for the third element',
                                                                       'type': 'int'}},
                                                  'args': [('val1',
                                                            'int',
                                                            'out'),
                                                           ('val2',
                                                            'int',
                                                            'out'),
                                                           ('val3',
                                                            'int',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGets the stored value of this data object as a triple of int integers. The data object must have been created as a triple of int integers for this to succeed.',
                                                  'inArgs': [],
                                                  'inverse': ('setData3Int',
                                                              False),
                                                  'outArgs': ['val1',
                                                              'val2',
                                                              'val3'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'val1': ['&'],
                                                                     'val2': ['&'],
                                                                     'val3': ['&']},
                                                  'types': {'val1': 'int',
                                                            'val2': 'int',
                                                            'val3': 'int'}}],
                                 'getData3Short': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                         'type': 'short'},
                                                                'val2': {'doc': 'storage for the second element ',
                                                                         'type': 'short'},
                                                                'val3': {'doc': 'storage for the third element',
                                                                         'type': 'short'}},
                                                    'args': [('val1',
                                                              'short',
                                                              'out'),
                                                             ('val2',
                                                              'short',
                                                              'out'),
                                                             ('val3',
                                                              'short',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGets the stored value of this data object as a triple of short integers. The data object must have been created as a pair of short integers for this to succeed.',
                                                    'inArgs': [],
                                                    'inverse': ('setData3Short',
                                                                False),
                                                    'outArgs': ['val1',
                                                                'val2',
                                                                'val3'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': ['&'],
                                                                       'val2': ['&'],
                                                                       'val3': ['&']},
                                                    'types': {'val1': 'short',
                                                              'val2': 'short',
                                                              'val3': 'short'}}],
                                 'getData4Double': [{'argInfo': {'val1': {'doc': 'storage for the first element ',
                                                                          'type': 'double'},
                                                                 'val2': {'doc': 'storage for the second element ',
                                                                          'type': 'double'},
                                                                 'val3': {'doc': 'storage for the third element ',
                                                                          'type': 'double'},
                                                                 'val4': {'doc': 'storage for the fourth element',
                                                                          'type': 'double'}},
                                                     'args': [('val1',
                                                               'double',
                                                               'out'),
                                                              ('val2',
                                                               'double',
                                                               'out'),
                                                              ('val3',
                                                               'double',
                                                               'out'),
                                                              ('val4',
                                                               'double',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the stored value of this data object as a quadruple of doubles. The data object must have been created as a quadruple of doubles for this to succeed.',
                                                     'inArgs': [],
                                                     'inverse': ('setData4Double',
                                                                 False),
                                                     'outArgs': ['val1',
                                                                 'val2',
                                                                 'val3',
                                                                 'val4'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'val1': ['&'],
                                                                        'val2': ['&'],
                                                                        'val3': ['&'],
                                                                        'val4': ['&']},
                                                     'types': {'val1': 'double',
                                                               'val2': 'double',
                                                               'val3': 'double',
                                                               'val4': 'double'}}],
                                 'numericType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the type of the numeric data object.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Type of data',
                                                                 'qualifiers': [],
                                                                 'type': ('MFnNumericData',
                                                                          'Type')},
                                                  'returnType': ('MFnNumericData',
                                                                 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'setData': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'short'},
                                                          'val2': {'doc': 'the second element',
                                                                   'type': 'short'}},
                                              'args': [('val1',
                                                        'short',
                                                        'in'),
                                                       ('val2',
                                                        'short',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1', 'val2'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': []},
                                              'types': {'val1': 'short',
                                                        'val2': 'short'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'int'},
                                                          'val2': {'doc': 'the second element',
                                                                   'type': 'int'}},
                                              'args': [('val1',
                                                        'int',
                                                        'in'),
                                                       ('val2',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1', 'val2'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': []},
                                              'types': {'val1': 'int',
                                                        'val2': 'int'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'float'},
                                                          'val2': {'doc': 'the second element',
                                                                   'type': 'float'}},
                                              'args': [('val1',
                                                        'float',
                                                        'in'),
                                                       ('val2',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1', 'val2'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': []},
                                              'types': {'val1': 'float',
                                                        'val2': 'float'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'the second element',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'in'),
                                                       ('val2',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1', 'val2'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': []},
                                              'types': {'val1': 'double',
                                                        'val2': 'double'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'short'},
                                                          'val2': {'doc': 'the second element ',
                                                                   'type': 'short'},
                                                          'val3': {'doc': 'the third element',
                                                                   'type': 'short'}},
                                              'args': [('val1',
                                                        'short',
                                                        'in'),
                                                       ('val2',
                                                        'short',
                                                        'in'),
                                                       ('val3',
                                                        'short',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1',
                                                         'val2',
                                                         'val3'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': [],
                                                                 'val3': []},
                                              'types': {'val1': 'short',
                                                        'val2': 'short',
                                                        'val3': 'short'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'int'},
                                                          'val2': {'doc': 'the second element ',
                                                                   'type': 'int'},
                                                          'val3': {'doc': 'the third element',
                                                                   'type': 'int'}},
                                              'args': [('val1',
                                                        'int',
                                                        'in'),
                                                       ('val2',
                                                        'int',
                                                        'in'),
                                                       ('val3',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1',
                                                         'val2',
                                                         'val3'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': [],
                                                                 'val3': []},
                                              'types': {'val1': 'int',
                                                        'val2': 'int',
                                                        'val3': 'int'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'float'},
                                                          'val2': {'doc': 'the second element ',
                                                                   'type': 'float'},
                                                          'val3': {'doc': 'the third element',
                                                                   'type': 'float'}},
                                              'args': [('val1',
                                                        'float',
                                                        'in'),
                                                       ('val2',
                                                        'float',
                                                        'in'),
                                                       ('val3',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1',
                                                         'val2',
                                                         'val3'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': [],
                                                                 'val3': []},
                                              'types': {'val1': 'float',
                                                        'val2': 'float',
                                                        'val3': 'float'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'the second element ',
                                                                   'type': 'double'},
                                                          'val3': {'doc': 'the third element',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'in'),
                                                       ('val2',
                                                        'double',
                                                        'in'),
                                                       ('val3',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1',
                                                         'val2',
                                                         'val3'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': [],
                                                                 'val3': []},
                                              'types': {'val1': 'double',
                                                        'val2': 'double',
                                                        'val3': 'double'}},
                                             {'argInfo': {'val1': {'doc': 'the first element ',
                                                                   'type': 'double'},
                                                          'val2': {'doc': 'the second element ',
                                                                   'type': 'double'},
                                                          'val3': {'doc': 'the third element ',
                                                                   'type': 'double'},
                                                          'val4': {'doc': 'the fourth element',
                                                                   'type': 'double'}},
                                              'args': [('val1',
                                                        'double',
                                                        'in'),
                                                       ('val2',
                                                        'double',
                                                        'in'),
                                                       ('val3',
                                                        'double',
                                                        'in'),
                                                       ('val4',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['val1',
                                                         'val2',
                                                         'val3',
                                                         'val4'],
                                              'inverse': ('getData',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'val1': [],
                                                                 'val2': [],
                                                                 'val3': [],
                                                                 'val4': []},
                                              'types': {'val1': 'double',
                                                        'val2': 'double',
                                                        'val3': 'double',
                                                        'val4': 'double'}}],
                                 'setData2Double': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                          'type': 'double'},
                                                                 'val2': {'doc': 'the second element',
                                                                          'type': 'double'}},
                                                     'args': [('val1',
                                                               'double',
                                                               'in'),
                                                              ('val2',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the stored value of this data object as a pair of doubles. The data object must have been created as a pair of doubles for this to succeed.',
                                                     'inArgs': ['val1',
                                                                'val2'],
                                                     'inverse': ('getData2Double',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'val1': [],
                                                                        'val2': []},
                                                     'types': {'val1': 'double',
                                                               'val2': 'double'}}],
                                 'setData2Float': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                         'type': 'float'},
                                                                'val2': {'doc': 'the second element',
                                                                         'type': 'float'}},
                                                    'args': [('val1',
                                                              'float',
                                                              'in'),
                                                             ('val2',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the stored value of this data object as a pair of floats. The data object must have been created as a pair of floats for this to succeed.',
                                                    'inArgs': ['val1',
                                                               'val2'],
                                                    'inverse': ('getData2Float',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': [],
                                                                       'val2': []},
                                                    'types': {'val1': 'float',
                                                              'val2': 'float'}}],
                                 'setData2Int': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                       'type': 'int'},
                                                              'val2': {'doc': 'the second element',
                                                                       'type': 'int'}},
                                                  'args': [('val1',
                                                            'int',
                                                            'in'),
                                                           ('val2',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets the stored value of this data object as a pair of int integers. The data object must have been created as a pair of int integers for this to succeed.',
                                                  'inArgs': ['val1',
                                                             'val2'],
                                                  'inverse': ('getData2Int',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'val1': [],
                                                                     'val2': []},
                                                  'types': {'val1': 'int',
                                                            'val2': 'int'}}],
                                 'setData2Short': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                         'type': 'short'},
                                                                'val2': {'doc': 'the second element',
                                                                         'type': 'short'}},
                                                    'args': [('val1',
                                                              'short',
                                                              'in'),
                                                             ('val2',
                                                              'short',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the stored value of this data object as a pair of short integers. The data object must have been created as a pair of short integers for this to succeed.',
                                                    'inArgs': ['val1',
                                                               'val2'],
                                                    'inverse': ('getData2Short',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': [],
                                                                       'val2': []},
                                                    'types': {'val1': 'short',
                                                              'val2': 'short'}}],
                                 'setData3Double': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                          'type': 'double'},
                                                                 'val2': {'doc': 'the second element ',
                                                                          'type': 'double'},
                                                                 'val3': {'doc': 'the third element',
                                                                          'type': 'double'}},
                                                     'args': [('val1',
                                                               'double',
                                                               'in'),
                                                              ('val2',
                                                               'double',
                                                               'in'),
                                                              ('val3',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the stored value of this data object as a triple of doubles. The data object must have been created as a triple of doubles for this to succeed.',
                                                     'inArgs': ['val1',
                                                                'val2',
                                                                'val3'],
                                                     'inverse': ('getData3Double',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'val1': [],
                                                                        'val2': [],
                                                                        'val3': []},
                                                     'types': {'val1': 'double',
                                                               'val2': 'double',
                                                               'val3': 'double'}}],
                                 'setData3Float': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                         'type': 'float'},
                                                                'val2': {'doc': 'the second element ',
                                                                         'type': 'float'},
                                                                'val3': {'doc': 'the third element',
                                                                         'type': 'float'}},
                                                    'args': [('val1',
                                                              'float',
                                                              'in'),
                                                             ('val2',
                                                              'float',
                                                              'in'),
                                                             ('val3',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the stored value of this data object as a triple of floats. The data object must have been created as a triple of floats for this to succeed.',
                                                    'inArgs': ['val1',
                                                               'val2',
                                                               'val3'],
                                                    'inverse': ('getData3Float',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': [],
                                                                       'val2': [],
                                                                       'val3': []},
                                                    'types': {'val1': 'float',
                                                              'val2': 'float',
                                                              'val3': 'float'}}],
                                 'setData3Int': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                       'type': 'int'},
                                                              'val2': {'doc': 'the second element ',
                                                                       'type': 'int'},
                                                              'val3': {'doc': 'the third element',
                                                                       'type': 'int'}},
                                                  'args': [('val1',
                                                            'int',
                                                            'in'),
                                                           ('val2',
                                                            'int',
                                                            'in'),
                                                           ('val3',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets the stored value of this data object as a triple of int integers. The data object must have been created as a triple of int integers for this to succeed.',
                                                  'inArgs': ['val1',
                                                             'val2',
                                                             'val3'],
                                                  'inverse': ('getData3Int',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'val1': [],
                                                                     'val2': [],
                                                                     'val3': []},
                                                  'types': {'val1': 'int',
                                                            'val2': 'int',
                                                            'val3': 'int'}}],
                                 'setData3Short': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                         'type': 'short'},
                                                                'val2': {'doc': 'the second element ',
                                                                         'type': 'short'},
                                                                'val3': {'doc': 'the third element',
                                                                         'type': 'short'}},
                                                    'args': [('val1',
                                                              'short',
                                                              'in'),
                                                             ('val2',
                                                              'short',
                                                              'in'),
                                                             ('val3',
                                                              'short',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the stored value of this data object as a triple of short integers. The data object must have been created as a triple of short integers for this to succeed.',
                                                    'inArgs': ['val1',
                                                               'val2',
                                                               'val3'],
                                                    'inverse': ('getData3Short',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val1': [],
                                                                       'val2': [],
                                                                       'val3': []},
                                                    'types': {'val1': 'short',
                                                              'val2': 'short',
                                                              'val3': 'short'}}],
                                 'setData4Double': [{'argInfo': {'val1': {'doc': 'the first element ',
                                                                          'type': 'double'},
                                                                 'val2': {'doc': 'the second element ',
                                                                          'type': 'double'},
                                                                 'val3': {'doc': 'the third element ',
                                                                          'type': 'double'},
                                                                 'val4': {'doc': 'the fourth element',
                                                                          'type': 'double'}},
                                                     'args': [('val1',
                                                               'double',
                                                               'in'),
                                                              ('val2',
                                                               'double',
                                                               'in'),
                                                              ('val3',
                                                               'double',
                                                               'in'),
                                                              ('val4',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the stored value of this data object as a quadruple of doubles. The data object must have been created as a quadruple of doubles for this to succeed.',
                                                     'inArgs': ['val1',
                                                                'val2',
                                                                'val3',
                                                                'val4'],
                                                     'inverse': ('getData4Double',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'val1': [],
                                                                        'val2': [],
                                                                        'val3': [],
                                                                        'val4': []},
                                                     'types': {'val1': 'double',
                                                               'val2': 'double',
                                                               'val3': 'double',
                                                               'val4': 'double'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {'Type': "Enum('Type', [('invalid', 0), ('kInvalid', 0), ('boolean', 1), ('kBoolean', 1), ('byte', 2), ('kByte', 2), ('char', 3), ('kChar', 3), ('short', 4), ('kShort', 4), ('k2Short', 5), ('k3Short', 6), ('long', 7), ('int', 7), ('kInt', 7), ('kLong', 7), ('k2Int', 8), ('k2Long', 8), ('k3Long', 9), ('k3Int', 9), ('int64', 10), ('kInt64', 10), ('float', 11), ('kFloat', 11), ('k2Float', 12), ('k3Float', 13), ('double', 14), ('kDouble', 14), ('k2Double', 15), ('k3Double', 16), ('k4Double', 17), ('addr', 18), ('kAddr', 18), ('last', 19), ('kLast', 19)], multiKeys=True)"}},
  'MFnNurbsCurve': {'enums': {'Form': {'valueDocs': {'closed': 'Endpoints are coincident.',
                                                     'invalid': '',
                                                     'kClosed': 'Endpoints are coincident.',
                                                     'kInvalid': '',
                                                     'kLast': '',
                                                     'kOpen': 'Ends are independent.',
                                                     'kPeriodic': 'Ends overlap such that there is no break in tangency.',
                                                     'last': '',
                                                     'open': 'Ends are independent.',
                                                     'periodic': 'Ends overlap such that there is no break in tangency.'},
                                       'values': "Enum('Form', {'kInvalid': 0, 'kOpen': 1, 'kClosed': 2, 'kPeriodic': 3, 'kLast': 4})"}},
                    'invertibles': [('setKnots', 'getKnots'),
                                    ('setCVs', 'getCVs'),
                                    ('setKnot', 'knot'),
                                    ('setCV', 'getCV')],
                    'methods': {'area': [{'argInfo': {'tolerance': {'doc': 'The amount of error (epsilon value) in the calculation ',
                                                                    'type': 'double'}},
                                          'args': [('tolerance',
                                                    'double',
                                                    'in')],
                                          'defaults': {'tolerance': 0.001},
                                          'deprecated': False,
                                          'doc': '\r\nThis method returns the area bounded by this curve. The curve must be closed and planar.',
                                          'inArgs': ['tolerance'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Status code',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'tolerance': []},
                                          'types': {'tolerance': 'double'}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'closestPoint': [{'argInfo': {'param': {'doc': 'If non-null, on successful returns this will contain the parameter value of the returned point. ',
                                                                        'type': 'double'},
                                                              'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                        'type': ('MSpace',
                                                                                 'Space')},
                                                              'toThisPoint': {'doc': 'The point to test ',
                                                                              'type': 'MPoint'},
                                                              'tolerance': {'doc': 'The amount of error (epsilon value) to allow in the calculation ',
                                                                            'type': 'double'}},
                                                  'args': [('toThisPoint',
                                                            'MPoint',
                                                            'in'),
                                                           ('param',
                                                            'double',
                                                            'in'),
                                                           ('tolerance',
                                                            'double',
                                                            'in'),
                                                           ('space',
                                                            ('MSpace',
                                                             'Space'),
                                                            'in')],
                                                  'defaults': {'param': None,
                                                               'space': ('MSpace',
                                                                         'Space',
                                                                         'kObject'),
                                                               'tolerance': 0.001},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method determines the closest point on the curve to the given point.',
                                                  'inArgs': ['toThisPoint',
                                                             'param',
                                                             'tolerance',
                                                             'space'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The point on the curve closest to the given point.',
                                                                 'qualifiers': [],
                                                                 'type': 'MPoint'},
                                                  'returnType': 'MPoint',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'param': ['*'],
                                                                     'space': [],
                                                                     'toThisPoint': ['const',
                                                                                     '&'],
                                                                     'tolerance': []},
                                                  'types': {'param': 'double',
                                                            'space': ('MSpace',
                                                                      'Space'),
                                                            'toThisPoint': 'MPoint',
                                                            'tolerance': 'double'}},
                                                 {'argInfo': {'param': {'doc': 'pointer to a double. If non-null, on successful returns this will contain the parameter value of the returned point. ',
                                                                        'type': 'double'},
                                                              'paramAsGuess': {'doc': "If true use the incoming 'param' value as a guess as to the location of the closest point. If the closest point lies within the same span as the guess then this can greatly speed up the search. If not then the search may be slowed a bit. ",
                                                                               'type': 'bool'},
                                                              'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                        'type': ('MSpace',
                                                                                 'Space')},
                                                              'toThisPoint': {'doc': 'The point to test ',
                                                                              'type': 'MPoint'},
                                                              'tolerance': {'doc': 'The amount of error (epsilon value) in the calculation ',
                                                                            'type': 'double'}},
                                                  'args': [('toThisPoint',
                                                            'MPoint',
                                                            'in'),
                                                           ('paramAsGuess',
                                                            'bool',
                                                            'in'),
                                                           ('param',
                                                            'double',
                                                            'in'),
                                                           ('tolerance',
                                                            'double',
                                                            'in'),
                                                           ('space',
                                                            ('MSpace',
                                                             'Space'),
                                                            'in')],
                                                  'defaults': {'param': None,
                                                               'space': ('MSpace',
                                                                         'Space',
                                                                         'kObject'),
                                                               'tolerance': 0.001},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method determines the closest point on the curve to the given point. Performance can be greatly increased by supplying a starting parameter value that is reasonably close to the final point.',
                                                  'inArgs': ['toThisPoint',
                                                             'paramAsGuess',
                                                             'param',
                                                             'tolerance',
                                                             'space'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The point on the curve closest to the given point.',
                                                                 'qualifiers': [],
                                                                 'type': 'MPoint'},
                                                  'returnType': 'MPoint',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'param': ['*'],
                                                                     'paramAsGuess': [],
                                                                     'space': [],
                                                                     'toThisPoint': ['const',
                                                                                     '&'],
                                                                     'tolerance': []},
                                                  'types': {'param': 'double',
                                                            'paramAsGuess': 'bool',
                                                            'space': ('MSpace',
                                                                      'Space'),
                                                            'toThisPoint': 'MPoint',
                                                            'tolerance': 'double'}}],
                                'copy': [{'argInfo': {'parentOrOwner': {'doc': 'the DAG parent or kNurbsCurveData the new curve will belong to ',
                                                                        'type': 'MObject'},
                                                      'source': {'doc': 'the curve to be copied ',
                                                                 'type': 'MObject'}},
                                          'args': [('source',
                                                    'MObject',
                                                    'in'),
                                                   ('parentOrOwner',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                          'deprecated': False,
                                          'doc': '\r\nThis method creates a copy of a nurbs curve.',
                                          'inArgs': ['source',
                                                     'parentOrOwner'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this curve is returned  If parentOrOwner is a DAG object then the curve shape is returned  The curve geometry is returned if parentOrOwner is of type kNurbsCurveData  ',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'parentOrOwner': ['&'],
                                                             'source': ['const',
                                                                        '&']},
                                          'types': {'parentOrOwner': 'MObject',
                                                    'source': 'MObject'}}],
                                'create': [{'argInfo': {'controlVertices': {'doc': 'an array of control vertices ',
                                                                            'type': 'MPointArray'},
                                                        'create2D': {'doc': 'true means that the Z-coordinates of the controlVertices will be ignored, giving a curve in the local XY plane ',
                                                                     'type': 'bool'},
                                                        'createRational': {'doc': 'true means curve being created will be rational ',
                                                                           'type': 'bool'},
                                                        'degree': {'doc': 'the degree to create the curve with ',
                                                                   'type': 'uint'},
                                                        'form': {'doc': 'either kOpen, kClosed, kPeriodic ',
                                                                 'type': ('MFnNurbsCurve',
                                                                          'Form')},
                                                        'knots': {'doc': 'an array of knots ',
                                                                  'type': 'MDoubleArray'},
                                                        'parentOrOwner': {'doc': 'the DAG parent or kNurbsCurveData the new curve will belong to ',
                                                                          'type': 'MObject'}},
                                            'args': [('controlVertices',
                                                      'MPointArray',
                                                      'in'),
                                                     ('knots',
                                                      'MDoubleArray',
                                                      'in'),
                                                     ('degree',
                                                      'uint',
                                                      'in'),
                                                     ('form',
                                                      ('MFnNurbsCurve',
                                                       'Form'),
                                                      'in'),
                                                     ('create2D',
                                                      'bool',
                                                      'in'),
                                                     ('createRational',
                                                      'bool',
                                                      'in'),
                                                     ('parentOrOwner',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                            'deprecated': False,
                                            'doc': '\r\nThis method creates a nurbs curve from the given control vertices and knot vector and sets this function set to operate on the new curve.',
                                            'inArgs': ['controlVertices',
                                                       'knots',
                                                       'degree',
                                                       'form',
                                                       'create2D',
                                                       'createRational',
                                                       'parentOrOwner'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this curve is returned  If parentOrOwner is a DAG object then the curve shape is returned  The curve geometry is returned if parentOrOwner is of type kNurbsCurveData  ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'controlVertices': ['const',
                                                                                   '&'],
                                                               'create2D': [],
                                                               'createRational': [],
                                                               'degree': ['unsigned'],
                                                               'form': [],
                                                               'knots': ['const',
                                                                         '&'],
                                                               'parentOrOwner': ['&']},
                                            'types': {'controlVertices': 'MPointArray',
                                                      'create2D': 'bool',
                                                      'createRational': 'bool',
                                                      'degree': 'uint',
                                                      'form': ('MFnNurbsCurve',
                                                               'Form'),
                                                      'knots': 'MDoubleArray',
                                                      'parentOrOwner': 'MObject'}},
                                           {'argInfo': {'parentOrOwner': {'doc': 'the DAG parent or kNurbsCurveData the new curve will belong to ',
                                                                          'type': 'MObject'},
                                                        'sources': {'doc': 'Input array of souce curves. ',
                                                                    'type': 'MObjectArray'}},
                                            'args': [('sources',
                                                      'MObjectArray',
                                                      'in'),
                                                     ('parentOrOwner',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                            'deprecated': False,
                                            'doc': '\r\nThis method creates a single curve that combines all the curves in the  MObjectArray . The method assumes the curves in the sources are good for building a single curve:  \n they are in the same direction,  \n they do not intersect themselves or each other,  \n there are no gaps between the endpoint of one curve and the start point of the next one in the array. \n \r\nIt is good enough to be C0 continouns (tangent breaks are okay).',
                                            'inArgs': ['sources',
                                                       'parentOrOwner'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this curve is returned  If parentOrOwner is a DAG object then the curve shape is returned  The curve geometry is returned if parentOrOwner is of type kNurbsCurveData  ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'parentOrOwner': ['&'],
                                                               'sources': ['const',
                                                                           '&']},
                                            'types': {'parentOrOwner': 'MObject',
                                                      'sources': 'MObjectArray'}}],
                                'createWithEditPoints': [{'argInfo': {'create2D': {'doc': 'true means that the Z-coordinates of the controlVertices will be ignored, giving a curve in the local XY plane ',
                                                                                   'type': 'bool'},
                                                                      'createRational': {'doc': 'true means curve being created will be rational ',
                                                                                         'type': 'bool'},
                                                                      'degree': {'doc': 'the degree to create the curve with ',
                                                                                 'type': 'uint'},
                                                                      'editPoints': {'doc': 'an array of edit points ',
                                                                                     'type': 'MPointArray'},
                                                                      'form': {'doc': 'either kOpen, kClosed, kPeriodic ',
                                                                               'type': ('MFnNurbsCurve',
                                                                                        'Form')},
                                                                      'parentOrOwner': {'doc': 'the DAG parent or kNurbsCurveData the new curve will belong to ',
                                                                                        'type': 'MObject'},
                                                                      'uniformParam': {'doc': 'true means curve being created will have uniform parameterization, false means chord length ',
                                                                                       'type': 'bool'}},
                                                          'args': [('editPoints',
                                                                    'MPointArray',
                                                                    'in'),
                                                                   ('degree',
                                                                    'uint',
                                                                    'in'),
                                                                   ('form',
                                                                    ('MFnNurbsCurve',
                                                                     'Form'),
                                                                    'in'),
                                                                   ('create2D',
                                                                    'bool',
                                                                    'in'),
                                                                   ('createRational',
                                                                    'bool',
                                                                    'in'),
                                                                   ('uniformParam',
                                                                    'bool',
                                                                    'in'),
                                                                   ('parentOrOwner',
                                                                    'MObject',
                                                                    'in')],
                                                          'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis method creates a nurbs curve from the given edit points and sets this function set to operate on the new curve.',
                                                          'inArgs': ['editPoints',
                                                                     'degree',
                                                                     'form',
                                                                     'create2D',
                                                                     'createRational',
                                                                     'uniformParam',
                                                                     'parentOrOwner'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this curve is returned  If parentOrOwner is a DAG object then the curve shape is returned  The curve geometry is returned if parentOrOwner is of type kNurbsCurveData  ',
                                                                         'qualifiers': [],
                                                                         'type': 'MObject'},
                                                          'returnType': 'MObject',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'create2D': [],
                                                                             'createRational': [],
                                                                             'degree': ['unsigned'],
                                                                             'editPoints': ['const',
                                                                                            '&'],
                                                                             'form': [],
                                                                             'parentOrOwner': ['&'],
                                                                             'uniformParam': []},
                                                          'types': {'create2D': 'bool',
                                                                    'createRational': 'bool',
                                                                    'degree': 'uint',
                                                                    'editPoints': 'MPointArray',
                                                                    'form': ('MFnNurbsCurve',
                                                                             'Form'),
                                                                    'parentOrOwner': 'MObject',
                                                                    'uniformParam': 'bool'}}],
                                'cv': [{'argInfo': {'index': {'doc': 'Index of the CV ',
                                                              'type': 'uint'}},
                                        'args': [('index',
                                                  'uint',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns a CV as a component.  MItCurveCV  can be used to examine or modify the returned CV.',
                                        'inArgs': [],
                                        'outArgs': ['index'],
                                        'returnInfo': {'doc': 'A handle to the CVs requested',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           'index': ['unsigned']},
                                        'types': {'index': 'uint'}}],
                                'cvs': [{'argInfo': {'endIndex': {'doc': 'the end index for the CVs to return ',
                                                                  'type': 'uint'},
                                                     'startIndex': {'doc': 'the start index for the CVs to return ',
                                                                    'type': 'uint'}},
                                         'args': [('startIndex',
                                                   'uint',
                                                   'in'),
                                                  ('endIndex',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns a contiguous group of CVs as a component.  MItCurveCV  can be used to examine or modify the returned CVs.',
                                         'inArgs': ['startIndex',
                                                    'endIndex'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'An MObject providing direct-access to the specified CVs',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'endIndex': ['unsigned'],
                                                            'startIndex': ['unsigned']},
                                         'types': {'endIndex': 'uint',
                                                   'startIndex': 'uint'}}],
                                'degree': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the degree of this curve. If the degree cannot be determined then 0 is returned.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The degree of this curve.',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'distanceToPoint': [{'argInfo': {'pt': {'doc': 'The point to calculate the distance to ',
                                                                        'type': 'MPoint'},
                                                                 'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                           'type': ('MSpace',
                                                                                    'Space')}},
                                                     'args': [('pt',
                                                               'MPoint',
                                                               'in'),
                                                              ('space',
                                                               ('MSpace',
                                                                'Space'),
                                                               'in')],
                                                     'defaults': {'space': ('MSpace',
                                                                            'Space',
                                                                            'kObject')},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the distance from the given point to the point on the curve which is closest to it.',
                                                     'inArgs': ['pt',
                                                                'space'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Status code',
                                                                    'qualifiers': [],
                                                                    'type': 'double'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'pt': ['const',
                                                                               '&'],
                                                                        'space': []},
                                                     'types': {'pt': 'MPoint',
                                                               'space': ('MSpace',
                                                                         'Space')}}],
                                'findLengthFromParam': [{'argInfo': {'param': {'doc': 'Parameter value on the curve ',
                                                                               'type': 'double'}},
                                                         'args': [('param',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the length along the curve corresponding to a given parameter value on the curve. If the length cannot be found for the given parameter value then ReturnStatus is set to kInvalidParameter and a length of zero is returned.',
                                                         'inArgs': ['param'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The length corresponding to the given parameter value. If the given parameter value cannot be found then a length of zero is returned.',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'param': []},
                                                         'types': {'param': 'double'}}],
                                'findParamFromLength': [{'argInfo': {'partLength': {'doc': 'Length along the curve to find parameter value at ',
                                                                                    'type': 'double'}},
                                                         'args': [('partLength',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the parameter value corresponding to a given length along the curve. If the parameter value cannot be found for the given length then ReturnStatus is set to kInvalidParameter and the parameter for the end point of the curve is returned.',
                                                         'inArgs': ['partLength'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The parameter value corresponding to the given length. If a parameter cannot be found for the given length then the parameter for the end point of the curve is returned.',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'partLength': []},
                                                         'types': {'partLength': 'double'}}],
                                'form': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThis method returns the form of the curve. The curve can be open, closed, or periodic.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' MFnNurbsCurve::kOpen  MFnNurbsCurve::kClosed  MFnNurbsCurve::kPeriodic  ',
                                                         'qualifiers': [],
                                                         'type': ('MFnNurbsCurve',
                                                                  'Form')},
                                          'returnType': ('MFnNurbsCurve',
                                                         'Form'),
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                                'getCV': [{'argInfo': {'index': {'doc': 'The index of the CV that will be retrieved ',
                                                                 'type': 'uint'},
                                                       'pt': {'doc': 'Storage for the CV ',
                                                              'type': 'MPoint'},
                                                       'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                 'type': ('MSpace',
                                                                          'Space')}},
                                           'args': [('index',
                                                     'uint',
                                                     'in'),
                                                    ('pt',
                                                     'MPoint',
                                                     'out'),
                                                    ('space',
                                                     ('MSpace',
                                                      'Space'),
                                                     'in')],
                                           'defaults': {'space': ('MSpace',
                                                                  'Space',
                                                                  'kObject')},
                                           'deprecated': False,
                                           'doc': '\r\nGet the CV at the given index.',
                                           'inArgs': ['index', 'space'],
                                           'inverse': ('setCV', False),
                                           'outArgs': ['pt'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned'],
                                                              'pt': ['&'],
                                                              'space': []},
                                           'types': {'index': 'uint',
                                                     'pt': 'MPoint',
                                                     'space': ('MSpace',
                                                               'Space')}}],
                                'getCVs': [{'argInfo': {'array': {'doc': 'The array of point values for the CVs ',
                                                                  'type': 'MPointArray'},
                                                        'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                  'type': ('MSpace',
                                                                           'Space')}},
                                            'args': [('array',
                                                      'MPointArray',
                                                      'out'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject')},
                                            'deprecated': False,
                                            'doc': '\r\nGet the positions of the CVs of this curve. The returned group can be accessed via the  MPointArray  class. Any modifications to these CVs will not affect this curve.  setCVs  should be called to modify the original curve.  updateCurve  should be called to cause the curve to redraw itself.',
                                            'inArgs': ['space'],
                                            'inverse': ('setCVs', False),
                                            'outArgs': ['array'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'array': ['&'],
                                                               'space': []},
                                            'types': {'array': 'MPointArray',
                                                      'space': ('MSpace',
                                                                'Space')}}],
                                'getDerivativesAtParm': [{'argInfo': {'dU': {'doc': 'Storage for the first order partial derivative with respect to u ',
                                                                             'type': 'MVector'},
                                                                      'dUU': {'doc': 'Pointer to storage for the second order partial derivative with respect to u',
                                                                              'type': 'MVector'},
                                                                      'param': {'doc': 'U parameter value to evaluate ',
                                                                                'type': 'double'},
                                                                      'pos': {'doc': 'Storage for the XYZ position of the curve ',
                                                                              'type': 'MPoint'},
                                                                      'space': {'doc': 'Coordinate space for the returned vectors ',
                                                                                'type': ('MSpace',
                                                                                         'Space')}},
                                                          'args': [('param',
                                                                    'double',
                                                                    'in'),
                                                                   ('pos',
                                                                    'MPoint',
                                                                    'out'),
                                                                   ('dU',
                                                                    'MVector',
                                                                    'out'),
                                                                   ('space',
                                                                    ('MSpace',
                                                                     'Space'),
                                                                    'in'),
                                                                   ('dUU',
                                                                    'MVector',
                                                                    'out')],
                                                          'defaults': {'dUU': None},
                                                          'deprecated': False,
                                                          'doc': '\r\nEvaluate the curve at the given parameter returning the position, first derivative and optionally the second derivative. Derivatives are not normalized.',
                                                          'inArgs': ['param',
                                                                     'space'],
                                                          'outArgs': ['pos',
                                                                      'dU',
                                                                      'dUU'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'dU': ['&'],
                                                                             'dUU': ['*'],
                                                                             'param': [],
                                                                             'pos': ['&'],
                                                                             'space': []},
                                                          'types': {'dU': 'MVector',
                                                                    'dUU': 'MVector',
                                                                    'param': 'double',
                                                                    'pos': 'MPoint',
                                                                    'space': ('MSpace',
                                                                              'Space')}}],
                                'getKnotDomain': [{'argInfo': {'end': {'doc': 'storage for the min parameter value',
                                                                       'type': 'double'},
                                                               'start': {'doc': 'storage for the max parameter value ',
                                                                         'type': 'double'}},
                                                   'args': [('start',
                                                             'double',
                                                             'out'),
                                                            ('end',
                                                             'double',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the range corresponding to the maximum and minimum parameter values for this curve.',
                                                   'inArgs': [],
                                                   'outArgs': ['start',
                                                               'end'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'end': ['&'],
                                                                      'start': ['&']},
                                                   'types': {'end': 'double',
                                                             'start': 'double'}}],
                                'getKnots': [{'argInfo': {'array': {'doc': 'storage where the parameter values of the knots for this curve will be copied',
                                                                    'type': 'MDoubleArray'}},
                                              'args': [('array',
                                                        'MDoubleArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method retrieves a copy of the knot array for this curve.',
                                              'inArgs': [],
                                              'inverse': ('setKnots',
                                                          False),
                                              'outArgs': ['array'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['&']},
                                              'types': {'array': 'MDoubleArray'}}],
                                'getParamAtPoint': [{'argInfo': {'atThisPoint': {'doc': 'Point to check ',
                                                                                 'type': 'MPoint'},
                                                                 'param': {'doc': 'storage for the parameter value ',
                                                                           'type': 'double'},
                                                                 'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                           'type': ('MSpace',
                                                                                    'Space')}},
                                                     'args': [('atThisPoint',
                                                               'MPoint',
                                                               'in'),
                                                              ('param',
                                                               'double',
                                                               'out'),
                                                              ('space',
                                                               ('MSpace',
                                                                'Space'),
                                                               'in')],
                                                     'defaults': {'space': ('MSpace',
                                                                            'Space',
                                                                            'kObject')},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method retrieves the parameter value corresponding to the given point on the curve.',
                                                     'inArgs': ['atThisPoint',
                                                                'space'],
                                                     'outArgs': ['param'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'atThisPoint': ['const',
                                                                                        '&'],
                                                                        'param': ['&'],
                                                                        'space': []},
                                                     'types': {'atThisPoint': 'MPoint',
                                                               'param': 'double',
                                                               'space': ('MSpace',
                                                                         'Space')}},
                                                    {'argInfo': {'atThisPoint': {'doc': 'Point to check ',
                                                                                 'type': 'MPoint'},
                                                                 'param': {'doc': 'storage for the parameter value ',
                                                                           'type': 'double'},
                                                                 'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                           'type': ('MSpace',
                                                                                    'Space')},
                                                                 'tolerance': {'doc': 'tolerance used for operation ',
                                                                               'type': 'double'}},
                                                     'args': [('atThisPoint',
                                                               'MPoint',
                                                               'in'),
                                                              ('param',
                                                               'double',
                                                               'out'),
                                                              ('tolerance',
                                                               'double',
                                                               'in'),
                                                              ('space',
                                                               ('MSpace',
                                                                'Space'),
                                                               'in')],
                                                     'defaults': {'space': ('MSpace',
                                                                            'Space',
                                                                            'kObject')},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method retrieves the parameter value corresponding to the given point on the curve.',
                                                     'inArgs': ['atThisPoint',
                                                                'tolerance',
                                                                'space'],
                                                     'outArgs': ['param'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'atThisPoint': ['const',
                                                                                        '&'],
                                                                        'param': ['&'],
                                                                        'space': [],
                                                                        'tolerance': []},
                                                     'types': {'atThisPoint': 'MPoint',
                                                               'param': 'double',
                                                               'space': ('MSpace',
                                                                         'Space'),
                                                               'tolerance': 'double'}}],
                                'getPointAtParam': [{'argInfo': {'param': {'doc': 'The parameter value that we are examining ',
                                                                           'type': 'double'},
                                                                 'point': {'doc': 'Storage for the point being returned ',
                                                                           'type': 'MPoint'},
                                                                 'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                           'type': ('MSpace',
                                                                                    'Space')}},
                                                     'args': [('param',
                                                               'double',
                                                               'in'),
                                                              ('point',
                                                               'MPoint',
                                                               'out'),
                                                              ('space',
                                                               ('MSpace',
                                                                'Space'),
                                                               'in')],
                                                     'defaults': {'space': ('MSpace',
                                                                            'Space',
                                                                            'kObject')},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the point in space that is at the given parameter value of the curve. If the parameter value does not give a valid point on the curve, then  MS::kInvalidParameter  is returned.',
                                                     'inArgs': ['param',
                                                                'space'],
                                                     'outArgs': ['point'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'param': [],
                                                                        'point': ['&'],
                                                                        'space': []},
                                                     'types': {'param': 'double',
                                                               'point': 'MPoint',
                                                               'space': ('MSpace',
                                                                         'Space')}}],
                                'hasHistoryOnCreate': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method determines if the shape was created with history.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': ' true shape has history  false shape does not have history  ',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                'isParamOnCurve': [{'argInfo': {'param': {'doc': 'The parameter value to check ',
                                                                          'type': 'double'}},
                                                    'args': [('param',
                                                              'double',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDetermines whether the specified parameter value is within the bounds of the knot vector of this curve',
                                                    'inArgs': ['param'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': ' true The parameter is on this curve.  false Parameter is NOT on this curve.  ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'param': []},
                                                    'types': {'param': 'double'}}],
                                'isPlanar': [{'argInfo': {'planeNormal': {'doc': 'Normal to the plane containing this curve ',
                                                                          'type': 'MVector'}},
                                              'args': [('planeNormal',
                                                        'MVector',
                                                        'in')],
                                              'defaults': {'planeNormal': None},
                                              'deprecated': False,
                                              'doc': '\r\nThis method determines if this curve is a planar curve. If planeNormal is non-NULL then the normal to the plane containing this curve is returned in this location.',
                                              'inArgs': ['planeNormal'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Status code',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'planeNormal': ['*']},
                                              'types': {'planeNormal': 'MVector'}}],
                                'isPointOnCurve': [{'argInfo': {'point': {'doc': 'The point to test ',
                                                                          'type': 'MPoint'},
                                                                'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                          'type': ('MSpace',
                                                                                   'Space')},
                                                                'tolerance': {'doc': 'The amount of error (epsilon value) in the calculation ',
                                                                              'type': 'double'}},
                                                    'args': [('point',
                                                              'MPoint',
                                                              'in'),
                                                             ('tolerance',
                                                              'double',
                                                              'in'),
                                                             ('space',
                                                              ('MSpace',
                                                               'Space'),
                                                              'in')],
                                                    'defaults': {'space': ('MSpace',
                                                                           'Space',
                                                                           'kObject'),
                                                                 'tolerance': 0.001},
                                                    'deprecated': False,
                                                    'doc': '\r\nDetermines whether the given point is on this curve.',
                                                    'inArgs': ['point',
                                                               'tolerance',
                                                               'space'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'true if the given point is on the curve, false otherwise.',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'point': ['const',
                                                                                 '&'],
                                                                       'space': [],
                                                                       'tolerance': []},
                                                    'types': {'point': 'MPoint',
                                                              'space': ('MSpace',
                                                                        'Space'),
                                                              'tolerance': 'double'}}],
                                'knot': [{'argInfo': {'index': {'doc': 'The knot index ',
                                                                'type': 'uint'}},
                                          'args': [('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGet the parameter value of the specified knot for this curve. Knot indices range from  0  to  numKnots()  - 1',
                                          'inArgs': ['index'],
                                          'inverse': ('setKnot', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The parameter value for the knot at index.',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'index': ['unsigned']},
                                          'types': {'index': 'uint'}}],
                                'length': [{'argInfo': {'tolerance': {'doc': 'The amount of error (epsilon value) in the calculation ',
                                                                      'type': 'double'}},
                                            'args': [('tolerance',
                                                      'double',
                                                      'in')],
                                            'defaults': {'tolerance': 0.001},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the arc length of this curve or 0.0 if it cannot be computed.',
                                            'inArgs': ['tolerance'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Status code',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'tolerance': []},
                                            'types': {'tolerance': 'double'}}],
                                'makeMultipleEndKnots': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis method gives end knots full multiplicity. This ensures the end points of the curve interpolate the first and last CVs. It can also be used to convert a periodic curve to a closed curve.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                'normal': [{'argInfo': {'param': {'doc': 'The parameter of the point on the curve from which to get the normal ',
                                                                  'type': 'double'},
                                                        'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                  'type': ('MSpace',
                                                                           'Space')}},
                                            'args': [('param',
                                                      'double',
                                                      'in'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject')},
                                            'deprecated': False,
                                            'doc': '\r\nThis method returns the normal at the given parameter value on the curve. For degree 1 curves the normal is the vector at right angles to the curve that lies in the average plane of the curve. For higher degrees the normal is defined by the local curvature at param.',
                                            'inArgs': ['param', 'space'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The normal vector for the given parameter',
                                                           'qualifiers': [],
                                                           'type': 'MVector'},
                                            'returnType': 'MVector',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'param': [],
                                                               'space': []},
                                            'types': {'param': 'double',
                                                      'space': ('MSpace',
                                                                'Space')}}],
                                'numCVs': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the number of CVs for this curve. If the number of CVs cannot be determined then 0 is returned.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The number of CVs for this curve.',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'numKnots': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the number of knots for this curve. If the number of knots cannot be determined then 0 is returned.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The number of knots for this curve.',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                'numSpans': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the number of spans for this curve. If the number of spans cannot be determined then 0 is returned.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The number of spans for this curve.',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                'rebuild': [{'argInfo': {'degree': {'doc': 'The degree of the resulting curve 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic',
                                                                    'type': 'uint'},
                                                         'endKnots': {'doc': 'End conditions for the curve 0 - uniform end knots, 1 - multiple end knots',
                                                                      'type': 'uint'},
                                                         'keepControlPoints': {'doc': 'If true, the CVs will remain the same.',
                                                                               'type': 'bool'},
                                                         'keepEndPoints': {'doc': 'If true, keep the endpoints the same',
                                                                           'type': 'bool'},
                                                         'keepRange': {'doc': 'Determine the parameterization for the resulting curve. 0 - reparameterize the resulting curve from 0 to 1, 1 - keep the original curve parameterization, 2 - reparameterize the result from 0 to number of spans',
                                                                       'type': 'uint'},
                                                         'keepTangents': {'doc': 'If true, keep the end tangents the same',
                                                                          'type': 'bool'},
                                                         'spans': {'doc': 'The number of spans in resulting curve',
                                                                   'type': 'uint'},
                                                         'tolerance': {'doc': 'The tolerance with which to rebuild',
                                                                       'type': 'float'}},
                                             'args': [('spans',
                                                       'uint',
                                                       'out'),
                                                      ('degree',
                                                       'uint',
                                                       'out'),
                                                      ('keepRange',
                                                       'uint',
                                                       'out'),
                                                      ('endKnots',
                                                       'uint',
                                                       'in'),
                                                      ('keepEndPoints',
                                                       'bool',
                                                       'in'),
                                                      ('keepTangents',
                                                       'bool',
                                                       'in'),
                                                      ('keepControlPoints',
                                                       'bool',
                                                       'in'),
                                                      ('tolerance',
                                                       'float',
                                                       'in')],
                                             'defaults': {'degree': 3,
                                                          'endKnots': 0,
                                                          'keepControlPoints': False,
                                                          'keepEndPoints': True,
                                                          'keepRange': 1,
                                                          'keepTangents': True,
                                                          'tolerance': '0.01f'},
                                             'deprecated': False,
                                             'doc': '\r\nThis method rebuilds a new curve based on the current curve and parameters.',
                                             'inArgs': ['endKnots',
                                                        'keepEndPoints',
                                                        'keepTangents',
                                                        'keepControlPoints',
                                                        'tolerance'],
                                             'outArgs': ['spans',
                                                         'degree',
                                                         'keepRange'],
                                             'returnInfo': {'doc': ' The new MObject containing the rebuilt curve  ',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'degree': ['unsigned'],
                                                                'endKnots': ['unsigned'],
                                                                'keepControlPoints': [],
                                                                'keepEndPoints': [],
                                                                'keepRange': ['unsigned'],
                                                                'keepTangents': [],
                                                                'spans': ['unsigned'],
                                                                'tolerance': []},
                                             'types': {'degree': 'uint',
                                                       'endKnots': 'uint',
                                                       'keepControlPoints': 'bool',
                                                       'keepEndPoints': 'bool',
                                                       'keepRange': 'uint',
                                                       'keepTangents': 'bool',
                                                       'spans': 'uint',
                                                       'tolerance': 'float'}}],
                                'removeKnot': [{'argInfo': {'atThisParam': {'doc': 'Status code ',
                                                                            'type': 'double'},
                                                            'removeAll': {'doc': 'How to handle multiple knots at the same param.',
                                                                          'type': 'bool'}},
                                                'args': [('atThisParam',
                                                          'double',
                                                          'in'),
                                                         ('removeAll',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'removeAll': False},
                                                'deprecated': False,
                                                'doc': '\r\nRemove one or more knots at the given parameter.',
                                                'inArgs': ['atThisParam',
                                                           'removeAll'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'atThisParam': [],
                                                                   'removeAll': []},
                                                'types': {'atThisParam': 'double',
                                                          'removeAll': 'bool'}}],
                                'reverse': [{'argInfo': {'constructionHistory': {'doc': "This parameter has no effect. Regardless of how it is set, if the function set was initialized with the DAG path of a curve node which already has history, then the reverse operation will be added into that history, otherwise the reverse operation will be applied directly to the curve's data and no history will be left behind.",
                                                                                 'type': 'bool'}},
                                             'args': [('constructionHistory',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'constructionHistory': False},
                                             'deprecated': False,
                                             'doc': '\r\nThis method reverse the curve direction.',
                                             'inArgs': ['constructionHistory'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'constructionHistory': []},
                                             'types': {'constructionHistory': 'bool'}}],
                                'setCV': [{'argInfo': {'index': {'doc': 'The index of the CV that will be changed ',
                                                                 'type': 'uint'},
                                                       'pt': {'doc': 'The new value that the CV will take ',
                                                              'type': 'MPoint'},
                                                       'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                 'type': ('MSpace',
                                                                          'Space')}},
                                           'args': [('index',
                                                     'uint',
                                                     'in'),
                                                    ('pt',
                                                     'MPoint',
                                                     'in'),
                                                    ('space',
                                                     ('MSpace',
                                                      'Space'),
                                                     'in')],
                                           'defaults': {'space': ('MSpace',
                                                                  'Space',
                                                                  'kObject')},
                                           'deprecated': False,
                                           'doc': '\r\nSet the CV at the given index to the given point. The method  updateCurve  should be called to trigger changes in the curve.',
                                           'inArgs': ['index',
                                                      'pt',
                                                      'space'],
                                           'inverse': ('getCV', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned'],
                                                              'pt': ['const',
                                                                     '&'],
                                                              'space': []},
                                           'types': {'index': 'uint',
                                                     'pt': 'MPoint',
                                                     'space': ('MSpace',
                                                               'Space')}}],
                                'setCVs': [{'argInfo': {'array': {'doc': 'The array of point values for the CVs ',
                                                                  'type': 'MPointArray'},
                                                        'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                  'type': ('MSpace',
                                                                           'Space')}},
                                            'args': [('array',
                                                      'MPointArray',
                                                      'in'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject')},
                                            'deprecated': False,
                                            'doc': '\r\nSet the CVs for this curve to the given points.',
                                            'inArgs': ['array', 'space'],
                                            'inverse': ('getCVs', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'array': ['const',
                                                                         '&'],
                                                               'space': []},
                                            'types': {'array': 'MPointArray',
                                                      'space': ('MSpace',
                                                                'Space')}}],
                                'setKnot': [{'argInfo': {'index': {'doc': 'Index of the knot to be set ',
                                                                   'type': 'uint'},
                                                         'param': {'doc': 'The parameter value that the knot will take',
                                                                   'type': 'double'}},
                                             'args': [('index',
                                                       'uint',
                                                       'in'),
                                                      ('param',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nSet the given knot's parameter value. Knot indices range from  0  to  numKnots()  - 1 .",
                                             'inArgs': ['index', 'param'],
                                             'inverse': ('knot', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'index': ['unsigned'],
                                                                'param': []},
                                             'types': {'index': 'uint',
                                                       'param': 'double'}}],
                                'setKnots': [{'argInfo': {'array': {'doc': 'a double array of knot points ',
                                                                    'type': 'MDoubleArray'},
                                                          'endIndex': {'doc': 'the ending index of the knots to be altered.',
                                                                       'type': 'uint'},
                                                          'startIndex': {'doc': 'the starting index of the knots to be altered. ',
                                                                         'type': 'uint'}},
                                              'args': [('array',
                                                        'MDoubleArray',
                                                        'in'),
                                                       ('startIndex',
                                                        'uint',
                                                        'in'),
                                                       ('endIndex',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method is used to set the values of a contiguous group of knots of the curve. The range of knots to set is specified using the start and end index. The knots of index startIndex to endIndex inclusive will be set using the value in the double array.',
                                              'inArgs': ['array',
                                                         'startIndex',
                                                         'endIndex'],
                                              'inverse': ('getKnots',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['const',
                                                                           '&'],
                                                                 'endIndex': ['unsigned'],
                                                                 'startIndex': ['unsigned']},
                                              'types': {'array': 'MDoubleArray',
                                                        'endIndex': 'uint',
                                                        'startIndex': 'uint'}}],
                                'tangent': [{'argInfo': {'param': {'doc': 'The parameter of the point on the curve from which to get the tangent ',
                                                                   'type': 'double'},
                                                         'space': {'doc': 'Specifies the coordinate system for this operation ',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('param',
                                                       'double',
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nThis method returns the tangent at the given parameter value on the curve. The resulting tangent vector is normalized.',
                                             'inArgs': ['param', 'space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The tangent vector for the given parameter',
                                                            'qualifiers': [],
                                                            'type': 'MVector'},
                                             'returnType': 'MVector',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'param': [],
                                                                'space': []},
                                             'types': {'param': 'double',
                                                       'space': ('MSpace',
                                                                 'Space')}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'updateCurve': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method signals that this curve has changed and needs to be recalculated.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                    'pymelEnums': {'Form': "Enum('Form', [('invalid', 0), ('kInvalid', 0), ('open', 1), ('kOpen', 1), ('closed', 2), ('kClosed', 2), ('periodic', 3), ('kPeriodic', 3), ('last', 4), ('kLast', 4)], multiKeys=True)"},
                    'pymelMethods': {'knot': 'getKnot'}},
  'MFnNurbsCurveData': {'enums': {},
                        'methods': {'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nClass name. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Nurbs Curve.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The new MObject ',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFunction set type. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFnNurbsSurface': {'enums': {'BoundaryType': {'valueDocs': {'closedSegment': 'Closed curve on a face.',
                                                               'inner': 'Inner boundary, clockwise.',
                                                               'invalidBoundary': '',
                                                               'kClosedSegment': 'Closed curve on a face.',
                                                               'kInner': 'Inner boundary, clockwise.',
                                                               'kInvalidBoundary': '',
                                                               'kOuter': 'Outer boundary, counter clockwise.',
                                                               'kSegment': 'Curve on a face.',
                                                               'outer': 'Outer boundary, counter clockwise.',
                                                               'segment': 'Curve on a face.'},
                                                 'values': "Enum('BoundaryType', {'kInvalidBoundary': 0, 'kOuter': 1, 'kInner': 2, 'kSegment': 3, 'kClosedSegment': 4})"},
                                'Form': {'valueDocs': {'closed': 'Edges are coincident.',
                                                       'invalid': '',
                                                       'kClosed': 'Edges are coincident.',
                                                       'kInvalid': '',
                                                       'kLast': '',
                                                       'kOpen': 'Edges are independent.',
                                                       'kPeriodic': 'Edges overlap such that there is no break in tangency.',
                                                       'last': '',
                                                       'open': 'Edges are independent.',
                                                       'periodic': 'Edges overlap such that there is no break in tangency.'},
                                         'values': "Enum('Form', {'kInvalid': 0, 'kOpen': 1, 'kClosed': 2, 'kPeriodic': 3, 'kLast': 4})"}},
                      'invertibles': [('setKnotsInV', 'getKnotsInV'),
                                      ('setKnotsInU', 'getKnotsInU'),
                                      ('setKnotInV', 'knotInV'),
                                      ('setKnotInU', 'knotInU'),
                                      ('setCVs', 'getCVs'),
                                      ('setCV', 'getCV'),
                                      ('setUVs', 'getUVs'),
                                      ('setUV', 'getUV')],
                      'methods': {'area': [{'argInfo': {'tolerance': {'doc': 'tolerance value to be used for computations ',
                                                                      'type': 'double'}},
                                            'args': [('tolerance',
                                                      'double',
                                                      'in')],
                                            'defaults': {'tolerance': 0.001},
                                            'deprecated': False,
                                            'doc': '\r\nCalculates the surface area of this nurbs surface. A value of 0.0 will be returned if the area cannot be determined successfully.',
                                            'inArgs': ['tolerance'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The area of this surface',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'tolerance': []},
                                            'types': {'tolerance': 'double'}},
                                           {'argInfo': {'space': {'doc': 'Coordinate space for the returned vectors ',
                                                                  'type': ('MSpace',
                                                                           'Space')},
                                                        'tolerance': {'doc': 'Tolerance value to be used for computations ',
                                                                      'type': 'double'}},
                                            'args': [('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in'),
                                                     ('tolerance',
                                                      'double',
                                                      'in')],
                                            'defaults': {'tolerance': 0.001},
                                            'deprecated': False,
                                            'doc': '\r\nCalculates the surface area of this nurbs surface in world or local space. A value of 0.0 will be returned if the area cannot be determined successfully.',
                                            'inArgs': ['space',
                                                       'tolerance'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The area of this surface',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'space': [],
                                                               'tolerance': []},
                                            'types': {'space': ('MSpace',
                                                                'Space'),
                                                      'tolerance': 'double'}}],
                                  'assignUV': [{'argInfo': {'cornerIndex': {'doc': 'The corner of the patch to map to ',
                                                                            'type': 'int'},
                                                            'patchId': {'doc': 'The patch to map to ',
                                                                        'type': 'int'},
                                                            'uvId': {'doc': 'The uv entry from the uv list that will be mapped',
                                                                     'type': 'int'}},
                                                'args': [('patchId',
                                                          'int',
                                                          'in'),
                                                         ('cornerIndex',
                                                          'int',
                                                          'in'),
                                                         ('uvId',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nMaps a texture coordinate to a the specified corner of a patch.',
                                                'inArgs': ['patchId',
                                                           'cornerIndex',
                                                           'uvId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'cornerIndex': [],
                                                                   'patchId': [],
                                                                   'uvId': []},
                                                'types': {'cornerIndex': 'int',
                                                          'patchId': 'int',
                                                          'uvId': 'int'}}],
                                  'assignUVs': [{'argInfo': {'uvCounts': {'doc': 'The uv counts for each patch in the surface ',
                                                                          'type': 'MIntArray'},
                                                             'uvIds': {'doc': 'The uv indices to be mapped to each patch-corner',
                                                                       'type': 'MIntArray'}},
                                                 'args': [('uvCounts',
                                                           'MIntArray',
                                                           'in'),
                                                          ('uvIds',
                                                           'MIntArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method maps all texture coordinates for the surface. The setUV/setUVs method is used to create the texture coordinate table for the surface. After the table is created, this method is used to map those values to each patch on a per-corner basis. The setUV/setUVs method should be called before the assignUVs method.',
                                                 'inArgs': ['uvCounts',
                                                            'uvIds'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'uvCounts': ['const',
                                                                                 '&'],
                                                                    'uvIds': ['const',
                                                                              '&']},
                                                 'types': {'uvCounts': 'MIntArray',
                                                           'uvIds': 'MIntArray'}}],
                                  'boundaryType': [{'argInfo': {'boundary': {'doc': 'the boundary to examine ',
                                                                             'type': 'uint'},
                                                                'region': {'doc': 'the region to examine ',
                                                                           'type': 'uint'}},
                                                    'args': [('region',
                                                              'uint',
                                                              'in'),
                                                             ('boundary',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the type of the specified boundary. The surface must be a trimmed surface.',
                                                    'inArgs': ['region',
                                                               'boundary'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The boundary type:  kInner an inner boundary, clockwise  kOuter an outer boundary, counter clockwise  kSegment a boundary segment (a curve on face)  kClosedSegment a closed boundary segment (a closed curve on face)  kInvalidBoundary an invalid boundary type  ',
                                                                   'qualifiers': [],
                                                                   'type': ('MFnNurbsSurface',
                                                                            'BoundaryType')},
                                                    'returnType': ('MFnNurbsSurface',
                                                                   'BoundaryType'),
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'boundary': ['unsigned'],
                                                                       'region': ['unsigned']},
                                                    'types': {'boundary': 'uint',
                                                              'region': 'uint'}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nClass name. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'clearUVs': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis method clears out all texture coordinates for the nurbsSurface, and leaves behind an empty UVset.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                  'closestPoint': [{'argInfo': {'ignoreTrimBoundaries': {'doc': 'If this is true and the surface is trimmed, look for the point on the entire, untrimmed surface ignoring any trim curves. ',
                                                                                         'type': 'bool'},
                                                                'paramU': {'doc': 'U parameter value of the closest point. Ignored if null. ',
                                                                           'type': 'double'},
                                                                'paramV': {'doc': 'V parameter value of the closest point. Ignored if null. ',
                                                                           'type': 'double'},
                                                                'space': {'doc': 'Coordinate space in which perform this operation, ',
                                                                          'type': ('MSpace',
                                                                                   'Space')},
                                                                'toThisPoint': {'doc': 'Point to be compared. ',
                                                                                'type': 'MPoint'},
                                                                'tolerance': {'doc': 'Tolerance value to be used for computations. ',
                                                                              'type': 'double'}},
                                                    'args': [('toThisPoint',
                                                              'MPoint',
                                                              'in'),
                                                             ('paramU',
                                                              'double',
                                                              'out'),
                                                             ('paramV',
                                                              'double',
                                                              'out'),
                                                             ('ignoreTrimBoundaries',
                                                              'bool',
                                                              'in'),
                                                             ('tolerance',
                                                              'double',
                                                              'in'),
                                                             ('space',
                                                              ('MSpace',
                                                               'Space'),
                                                              'in')],
                                                    'defaults': {'ignoreTrimBoundaries': False,
                                                                 'paramU': None,
                                                                 'paramV': None,
                                                                 'space': ('MSpace',
                                                                           'Space',
                                                                           'kObject'),
                                                                 'tolerance': 0.001},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the closest point on this surface to the given point.',
                                                    'inArgs': ['toThisPoint',
                                                               'ignoreTrimBoundaries',
                                                               'tolerance',
                                                               'space'],
                                                    'outArgs': ['paramU',
                                                                'paramV'],
                                                    'returnInfo': {'doc': 'The closest point on this surface to the given point',
                                                                   'qualifiers': [],
                                                                   'type': 'MPoint'},
                                                    'returnType': 'MPoint',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'ignoreTrimBoundaries': [],
                                                                       'paramU': ['*'],
                                                                       'paramV': ['*'],
                                                                       'space': [],
                                                                       'toThisPoint': ['const',
                                                                                       '&'],
                                                                       'tolerance': []},
                                                    'types': {'ignoreTrimBoundaries': 'bool',
                                                              'paramU': 'double',
                                                              'paramV': 'double',
                                                              'space': ('MSpace',
                                                                        'Space'),
                                                              'toThisPoint': 'MPoint',
                                                              'tolerance': 'double'}},
                                                   {'argInfo': {'ignoreTrimBoundaries': {'doc': 'if this is true and the surface is trimmed, look for the point on the entire, untrimmed surface ignoring any trim curves. ',
                                                                                         'type': 'bool'},
                                                                'paramAsStart': {'doc': 'If true use the value pointed to by paramU and paramV as a starting point for the search ',
                                                                                 'type': 'bool'},
                                                                'paramU': {'doc': "Returns the U parameter value of the closest point. if 'paramAsStart' is true then the value initially passed in by the caller will be used as the starting U value for the search. Ignored if null. ",
                                                                           'type': 'double'},
                                                                'paramV': {'doc': "Returns the V parameter value of the closest point. if 'paramAsStart' is true then the value initially passed in by the caller will be used as the starting V value for the search. Ignored if null. ",
                                                                           'type': 'double'},
                                                                'space': {'doc': 'Coordinate space in which perform this operation ',
                                                                          'type': ('MSpace',
                                                                                   'Space')},
                                                                'toThisPoint': {'doc': 'Point to be compared ',
                                                                                'type': 'MPoint'},
                                                                'tolerance': {'doc': 'tolerance value to be used for computations ',
                                                                              'type': 'double'}},
                                                    'args': [('toThisPoint',
                                                              'MPoint',
                                                              'in'),
                                                             ('paramAsStart',
                                                              'bool',
                                                              'in'),
                                                             ('paramU',
                                                              'double',
                                                              'in'),
                                                             ('paramV',
                                                              'double',
                                                              'in'),
                                                             ('ignoreTrimBoundaries',
                                                              'bool',
                                                              'in'),
                                                             ('tolerance',
                                                              'double',
                                                              'in'),
                                                             ('space',
                                                              ('MSpace',
                                                               'Space'),
                                                              'in')],
                                                    'defaults': {'ignoreTrimBoundaries': False,
                                                                 'space': ('MSpace',
                                                                           'Space',
                                                                           'kObject'),
                                                                 'tolerance': 0.001},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the closest point on this surface to the given point.',
                                                    'inArgs': ['toThisPoint',
                                                               'paramAsStart',
                                                               'paramU',
                                                               'paramV',
                                                               'ignoreTrimBoundaries',
                                                               'tolerance',
                                                               'space'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The closest point on this surface to the given point',
                                                                   'qualifiers': [],
                                                                   'type': 'MPoint'},
                                                    'returnType': 'MPoint',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'ignoreTrimBoundaries': [],
                                                                       'paramAsStart': [],
                                                                       'paramU': ['*'],
                                                                       'paramV': ['*'],
                                                                       'space': [],
                                                                       'toThisPoint': ['const',
                                                                                       '&'],
                                                                       'tolerance': []},
                                                    'types': {'ignoreTrimBoundaries': 'bool',
                                                              'paramAsStart': 'bool',
                                                              'paramU': 'double',
                                                              'paramV': 'double',
                                                              'space': ('MSpace',
                                                                        'Space'),
                                                              'toThisPoint': 'MPoint',
                                                              'tolerance': 'double'}}],
                                  'copy': [{'argInfo': {'parentOrOwner': {'doc': 'the DAG parent or kNurbsSurfaceData the new surface will belong to ',
                                                                          'type': 'MObject'},
                                                        'source': {'doc': 'the surface to be copied ',
                                                                   'type': 'MObject'}},
                                            'args': [('source',
                                                      'MObject',
                                                      'in'),
                                                     ('parentOrOwner',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                            'deprecated': False,
                                            'doc': '\r\nThis method creates a copy of a nurbs surface.',
                                            'inArgs': ['source',
                                                       'parentOrOwner'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kNurbsSurfaceData  ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'parentOrOwner': [],
                                                               'source': ['const',
                                                                          '&']},
                                            'types': {'parentOrOwner': 'MObject',
                                                      'source': 'MObject'}}],
                                  'create': [{'argInfo': {'controlVertices': {'doc': 'an array of control vertices ',
                                                                              'type': 'MPointArray'},
                                                          'createRational': {'doc': 'create as rational (true) or non-rational (false) surface ',
                                                                             'type': 'bool'},
                                                          'degreeInU': {'doc': 'degree of first set of basis functions ',
                                                                        'type': 'uint'},
                                                          'degreeInV': {'doc': 'degree of second set of basis functions ',
                                                                        'type': 'uint'},
                                                          'formU': {'doc': 'open, closed, periodic in U ',
                                                                    'type': ('MFnNurbsSurface',
                                                                             'Form')},
                                                          'formV': {'doc': 'open, closed, periodic in V ',
                                                                    'type': ('MFnNurbsSurface',
                                                                             'Form')},
                                                          'parentOrOwner': {'doc': 'specifies what to do with the surface. If a DAG object or nullptr is given then a transform will be created for the new surface and placed under the specified (optional)parent. If kNurbsSurfaceData is given then the surface will become its data. ',
                                                                            'type': 'MObject'},
                                                          'uKnotSequences': {'doc': 'an array of U knot values ',
                                                                             'type': 'MDoubleArray'},
                                                          'vKnotSequences': {'doc': 'an array of V knot values ',
                                                                             'type': 'MDoubleArray'}},
                                              'args': [('controlVertices',
                                                        'MPointArray',
                                                        'in'),
                                                       ('uKnotSequences',
                                                        'MDoubleArray',
                                                        'in'),
                                                       ('vKnotSequences',
                                                        'MDoubleArray',
                                                        'in'),
                                                       ('degreeInU',
                                                        'uint',
                                                        'in'),
                                                       ('degreeInV',
                                                        'uint',
                                                        'in'),
                                                       ('formU',
                                                        ('MFnNurbsSurface',
                                                         'Form'),
                                                        'in'),
                                                       ('formV',
                                                        ('MFnNurbsSurface',
                                                         'Form'),
                                                        'in'),
                                                       ('createRational',
                                                        'bool',
                                                        'in'),
                                                       ('parentOrOwner',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                              'deprecated': False,
                                              'doc': '\r\nCreates a nurbs surface from the specified data and sets this function set to operate on the new surface.',
                                              'inArgs': ['controlVertices',
                                                         'uKnotSequences',
                                                         'vKnotSequences',
                                                         'degreeInU',
                                                         'degreeInV',
                                                         'formU',
                                                         'formV',
                                                         'createRational',
                                                         'parentOrOwner'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kNurbsSurfaceData  ',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'controlVertices': ['const',
                                                                                     '&'],
                                                                 'createRational': [],
                                                                 'degreeInU': ['unsigned'],
                                                                 'degreeInV': ['unsigned'],
                                                                 'formU': [],
                                                                 'formV': [],
                                                                 'parentOrOwner': [],
                                                                 'uKnotSequences': ['const',
                                                                                    '&'],
                                                                 'vKnotSequences': ['const',
                                                                                    '&']},
                                              'types': {'controlVertices': 'MPointArray',
                                                        'createRational': 'bool',
                                                        'degreeInU': 'uint',
                                                        'degreeInV': 'uint',
                                                        'formU': ('MFnNurbsSurface',
                                                                  'Form'),
                                                        'formV': ('MFnNurbsSurface',
                                                                  'Form'),
                                                        'parentOrOwner': 'MObject',
                                                        'uKnotSequences': 'MDoubleArray',
                                                        'vKnotSequences': 'MDoubleArray'}}],
                                  'cv': [{'argInfo': {'indexU': {'doc': 'U index of CV ',
                                                                 'type': 'uint'},
                                                      'indexV': {'doc': 'V index of CV ',
                                                                 'type': 'uint'}},
                                          'args': [('indexU',
                                                    'uint',
                                                    'in'),
                                                   ('indexV',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns a component for the specified CV.',
                                          'inArgs': ['indexU', 'indexV'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The cv component',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'indexU': ['unsigned'],
                                                             'indexV': ['unsigned']},
                                          'types': {'indexU': 'uint',
                                                    'indexV': 'uint'}}],
                                  'cvsInU': [{'argInfo': {'endIndex': {'doc': 'end CV index in U ',
                                                                       'type': 'uint'},
                                                          'rowIndex': {'doc': 'row index ',
                                                                       'type': 'uint'},
                                                          'startIndex': {'doc': 'start CV index in U ',
                                                                         'type': 'uint'}},
                                              'args': [('startIndex',
                                                        'uint',
                                                        'in'),
                                                       ('endIndex',
                                                        'uint',
                                                        'in'),
                                                       ('rowIndex',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns a component for the specified CVs.',
                                              'inArgs': ['startIndex',
                                                         'endIndex',
                                                         'rowIndex'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The component for the CVs on the given U direction.',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'endIndex': ['unsigned'],
                                                                 'rowIndex': ['unsigned'],
                                                                 'startIndex': ['unsigned']},
                                              'types': {'endIndex': 'uint',
                                                        'rowIndex': 'uint',
                                                        'startIndex': 'uint'}}],
                                  'cvsInV': [{'argInfo': {'endIndex': {'doc': 'end CV index in V ',
                                                                       'type': 'uint'},
                                                          'rowIndex': {'doc': 'row index ',
                                                                       'type': 'uint'},
                                                          'startIndex': {'doc': 'start CV index in V ',
                                                                         'type': 'uint'}},
                                              'args': [('startIndex',
                                                        'uint',
                                                        'in'),
                                                       ('endIndex',
                                                        'uint',
                                                        'in'),
                                                       ('rowIndex',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns a component for the specified CVs on the given V direction.',
                                              'inArgs': ['startIndex',
                                                         'endIndex',
                                                         'rowIndex'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The component for the CVs',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'endIndex': ['unsigned'],
                                                                 'rowIndex': ['unsigned'],
                                                                 'startIndex': ['unsigned']},
                                              'types': {'endIndex': 'uint',
                                                        'rowIndex': 'uint',
                                                        'startIndex': 'uint'}}],
                                  'degreeU': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the degree of the surface in U (1 - 3).',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The degree in U',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                  'degreeV': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the degree of the surface in V (1 - 3).',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The degree in V',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                  'distanceToPoint': [{'argInfo': {'pt': {'doc': 'Point to calculate distance from ',
                                                                          'type': 'MPoint'},
                                                                   'space': {'doc': 'Coordinate space for which to perform operation ',
                                                                             'type': ('MSpace',
                                                                                      'Space')}},
                                                       'args': [('pt',
                                                                 'MPoint',
                                                                 'in'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject')},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the distance from the given point to the closest point on the surface.',
                                                       'inArgs': ['pt',
                                                                  'space'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The distance to the given point from this surface',
                                                                      'qualifiers': [],
                                                                      'type': 'double'},
                                                       'returnType': 'double',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'pt': ['const',
                                                                                 '&'],
                                                                          'space': []},
                                                       'types': {'pt': 'MPoint',
                                                                 'space': ('MSpace',
                                                                           'Space')}}],
                                  'edge': [{'argInfo': {'boundary': {'doc': 'the boundary to examine ',
                                                                     'type': 'uint'},
                                                        'edge': {'doc': 'the boundary edge to examine ',
                                                                 'type': 'uint'},
                                                        'paramEdge': {'doc': 'if true then 2D param edges are returned, otherwise a 3D edge is returned. ',
                                                                      'type': 'bool'},
                                                        'region': {'doc': 'the trimmed region containing the edge ',
                                                                   'type': 'uint'}},
                                            'args': [('region',
                                                      'uint',
                                                      'in'),
                                                     ('boundary',
                                                      'uint',
                                                      'in'),
                                                     ('edge',
                                                      'uint',
                                                      'in'),
                                                     ('paramEdge',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'paramEdge': False},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the specified edge of a trim boundary.',
                                            'inArgs': ['region',
                                                       'boundary',
                                                       'edge',
                                                       'paramEdge'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A curve for the specified edge',
                                                           'qualifiers': [],
                                                           'type': 'MObjectArray'},
                                            'returnType': 'MObjectArray',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'boundary': ['unsigned'],
                                                               'edge': ['unsigned'],
                                                               'paramEdge': [],
                                                               'region': ['unsigned']},
                                            'types': {'boundary': 'uint',
                                                      'edge': 'uint',
                                                      'paramEdge': 'bool',
                                                      'region': 'uint'}}],
                                  'formInU': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the form of this surface in U. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The form of this surface in U',
                                                              'qualifiers': [],
                                                              'type': ('MFnNurbsSurface',
                                                                       'Form')},
                                               'returnType': ('MFnNurbsSurface',
                                                              'Form'),
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                  'formInV': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the form of this surface in V. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The form of this surface in V',
                                                              'qualifiers': [],
                                                              'type': ('MFnNurbsSurface',
                                                                       'Form')},
                                               'returnType': ('MFnNurbsSurface',
                                                              'Form'),
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                  'getAssignedUVs': [{'argInfo': {'uvCounts': {'doc': 'The uv counts for each patch in the surface ',
                                                                               'type': 'MIntArray'},
                                                                  'uvIds': {'doc': 'The uv indices to be mapped to each patch-corner',
                                                                            'type': 'MIntArray'}},
                                                      'args': [('uvCounts',
                                                                'MIntArray',
                                                                'out'),
                                                               ('uvIds',
                                                                'MIntArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet assigned UVs. This method finds all texture coordinates for the surface that have been mapped, and returns them in the same format as assignUVs. The setUV/setUVs method is used to create the texture coordinate table for the surface and this method is used to map those values to each patch on a per-corner basis.',
                                                      'inArgs': [],
                                                      'outArgs': ['uvCounts',
                                                                  'uvIds'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'uvCounts': ['&'],
                                                                         'uvIds': ['&']},
                                                      'types': {'uvCounts': 'MIntArray',
                                                                'uvIds': 'MIntArray'}}],
                                  'getCV': [{'argInfo': {'indexU': {'doc': 'U index of CV ',
                                                                    'type': 'uint'},
                                                         'indexV': {'doc': 'V index of CV ',
                                                                    'type': 'uint'},
                                                         'pnt': {'doc': 'storage for the CV location ',
                                                                 'type': 'MPoint'},
                                                         'space': {'doc': 'coordinate space for the CV',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('indexU',
                                                       'uint',
                                                       'in'),
                                                      ('indexV',
                                                       'uint',
                                                       'in'),
                                                      ('pnt',
                                                       'MPoint',
                                                       'out'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nGet the location of the specified CV.',
                                             'inArgs': ['indexU',
                                                        'indexV',
                                                        'space'],
                                             'inverse': ('setCV', False),
                                             'outArgs': ['pnt'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'indexU': ['unsigned'],
                                                                'indexV': ['unsigned'],
                                                                'pnt': ['&'],
                                                                'space': []},
                                             'types': {'indexU': 'uint',
                                                       'indexV': 'uint',
                                                       'pnt': 'MPoint',
                                                       'space': ('MSpace',
                                                                 'Space')}}],
                                  'getCVs': [{'argInfo': {'array': {'doc': 'the array of point values for the CVs ',
                                                                    'type': 'MPointArray'},
                                                          'space': {'doc': 'specifies the coordinate system for this operation',
                                                                    'type': ('MSpace',
                                                                             'Space')}},
                                              'args': [('array',
                                                        'MPointArray',
                                                        'out'),
                                                       ('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': '\r\nGet the positions of the CVs on this surface. The returned group can be accessed via the  MPointArray  class.  numCVsInU()  *  numCVsInV()  points will be returned. Converting from uIndex, vIndex is done by "index = numCVsInV() * uIndex + vIndex".',
                                              'inArgs': ['space'],
                                              'inverse': ('setCVs',
                                                          False),
                                              'outArgs': ['array'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['&'],
                                                                 'space': []},
                                              'types': {'array': 'MPointArray',
                                                        'space': ('MSpace',
                                                                  'Space')}}],
                                  'getConnectedShaders': [{'argInfo': {'indices': {'doc': 'Storage for indices matching patches to shaders. For each patch, this array contains the index into the shaders array for the shader assigned to the patch.',
                                                                                   'type': 'MIntArray'},
                                                                       'instanceNumber': {'doc': 'The instance number of the surface to query ',
                                                                                          'type': 'uint'},
                                                                       'shaders': {'doc': 'Storage for set objects (shader objects) ',
                                                                                   'type': 'MObjectArray'}},
                                                           'args': [('instanceNumber',
                                                                     'uint',
                                                                     'in'),
                                                                    ('shaders',
                                                                     'MObjectArray',
                                                                     'out'),
                                                                    ('indices',
                                                                     'MIntArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns all the shaders (sets) connected to the specified instance of this surface, as well as an array of patch/shader assignments. The indices array will hold, for each patch in the surface, an index into the shaders array. If a patch does not have a shader assigned to it, the value of the index will be -1.',
                                                           'inArgs': ['instanceNumber'],
                                                           'outArgs': ['shaders',
                                                                       'indices'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'indices': ['&'],
                                                                              'instanceNumber': ['unsigned'],
                                                                              'shaders': ['&']},
                                                           'types': {'indices': 'MIntArray',
                                                                     'instanceNumber': 'uint',
                                                                     'shaders': 'MObjectArray'}}],
                                  'getDataObject': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns an  MObject  if the class has been constructed with an  MFn::kNurbsSurfaceData  entity, otherwise  MObject::kNullObj  is returned.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                  'getDerivativesAtParm': [{'argInfo': {'dU': {'doc': 'Storage for the first order partial derivative with respect to u ',
                                                                               'type': 'MVector'},
                                                                        'dUU': {'doc': 'Pointer to storage for the second order partial derivative with respect to u ',
                                                                                'type': 'MVector'},
                                                                        'dUV': {'doc': 'Pointer to storage for the second order partial derivative with respect to u then v',
                                                                                'type': 'MVector'},
                                                                        'dV': {'doc': 'Storage for the first order partial derivative with respect to v ',
                                                                               'type': 'MVector'},
                                                                        'dVV': {'doc': 'Pointer to storage for the second order partial derivative with respect to v ',
                                                                                'type': 'MVector'},
                                                                        'paramInU': {'doc': 'U parameter value to evaluate ',
                                                                                     'type': 'double'},
                                                                        'paramInV': {'doc': 'V parameter value to evaluate ',
                                                                                     'type': 'double'},
                                                                        'pos': {'doc': 'Storage for the XYZ position of (u,v) ',
                                                                                'type': 'MPoint'},
                                                                        'space': {'doc': 'Coordinate space for the returned vectors ',
                                                                                  'type': ('MSpace',
                                                                                           'Space')}},
                                                            'args': [('paramInU',
                                                                      'double',
                                                                      'in'),
                                                                     ('paramInV',
                                                                      'double',
                                                                      'in'),
                                                                     ('pos',
                                                                      'MPoint',
                                                                      'out'),
                                                                     ('dU',
                                                                      'MVector',
                                                                      'out'),
                                                                     ('dV',
                                                                      'MVector',
                                                                      'out'),
                                                                     ('space',
                                                                      ('MSpace',
                                                                       'Space'),
                                                                      'in'),
                                                                     ('dUU',
                                                                      'MVector',
                                                                      'out'),
                                                                     ('dVV',
                                                                      'MVector',
                                                                      'out'),
                                                                     ('dUV',
                                                                      'MVector',
                                                                      'out')],
                                                            'defaults': {'dUU': None,
                                                                         'dUV': None,
                                                                         'dVV': None},
                                                            'deprecated': False,
                                                            'doc': '\r\nEvaluate the surface at the given (u,v) coordinate returning position, first derivatives and optionally second derivative information. The returned derivative vectors are not normalized. If either dUU, dVV, or dUV is set to nullptr, the second derivatives will not be computed and execution time wil be faster.',
                                                            'inArgs': ['paramInU',
                                                                       'paramInV',
                                                                       'space'],
                                                            'outArgs': ['pos',
                                                                        'dU',
                                                                        'dV',
                                                                        'dUU',
                                                                        'dVV',
                                                                        'dUV'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'dU': ['&'],
                                                                               'dUU': ['*'],
                                                                               'dUV': ['*'],
                                                                               'dV': ['&'],
                                                                               'dVV': ['*'],
                                                                               'paramInU': [],
                                                                               'paramInV': [],
                                                                               'pos': ['&'],
                                                                               'space': []},
                                                            'types': {'dU': 'MVector',
                                                                      'dUU': 'MVector',
                                                                      'dUV': 'MVector',
                                                                      'dV': 'MVector',
                                                                      'dVV': 'MVector',
                                                                      'paramInU': 'double',
                                                                      'paramInV': 'double',
                                                                      'pos': 'MPoint',
                                                                      'space': ('MSpace',
                                                                                'Space')}}],
                                  'getKnotDomain': [{'argInfo': {'endU': {'doc': 'End U parameter value ',
                                                                          'type': 'double'},
                                                                 'endV': {'doc': 'End V parameter value',
                                                                          'type': 'double'},
                                                                 'startU': {'doc': 'Start U parameter value ',
                                                                            'type': 'double'},
                                                                 'startV': {'doc': 'Start V parameter value ',
                                                                            'type': 'double'}},
                                                     'args': [('startU',
                                                               'double',
                                                               'out'),
                                                              ('endU',
                                                               'double',
                                                               'out'),
                                                              ('startV',
                                                               'double',
                                                               'out'),
                                                              ('endV',
                                                               'double',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the maximum and minimum U and V paramter values for this surface.',
                                                     'inArgs': [],
                                                     'outArgs': ['startU',
                                                                 'endU',
                                                                 'startV',
                                                                 'endV'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'endU': ['&'],
                                                                        'endV': ['&'],
                                                                        'startU': ['&'],
                                                                        'startV': ['&']},
                                                     'types': {'endU': 'double',
                                                               'endV': 'double',
                                                               'startU': 'double',
                                                               'startV': 'double'}}],
                                  'getKnotsInU': [{'argInfo': {'array': {'doc': 'Storage for the knot values',
                                                                         'type': 'MDoubleArray'}},
                                                   'args': [('array',
                                                             'MDoubleArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the knots along the U direction for this surface.',
                                                   'inArgs': [],
                                                   'inverse': ('setKnotsInU',
                                                               False),
                                                   'outArgs': ['array'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'array': ['&']},
                                                   'types': {'array': 'MDoubleArray'}}],
                                  'getKnotsInV': [{'argInfo': {'array': {'doc': 'Storage for the knot values',
                                                                         'type': 'MDoubleArray'}},
                                                   'args': [('array',
                                                             'MDoubleArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the knots along the V direction for this surface.',
                                                   'inArgs': [],
                                                   'inverse': ('setKnotsInV',
                                                               False),
                                                   'outArgs': ['array'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'array': ['&']},
                                                   'types': {'array': 'MDoubleArray'}}],
                                  'getParamAtPoint': [{'argInfo': {'atThisPoint': {'doc': 'Location of parameter to obtain ',
                                                                                   'type': 'MPoint'},
                                                                   'ignoreTrimBoundaries': {'doc': 'if this is true and the surface is trimmed, look for the param on the entire, untrimmed surface ignoring any trim curves. ',
                                                                                            'type': 'bool'},
                                                                   'paramU': {'doc': 'storage for the U parameter value ',
                                                                              'type': 'double'},
                                                                   'paramV': {'doc': 'storage for the V parameter value ',
                                                                              'type': 'double'},
                                                                   'space': {'doc': 'Coordinate space in which to perform this operation ',
                                                                             'type': ('MSpace',
                                                                                      'Space')},
                                                                   'tolerance': {'doc': 'tolerance used in this operation',
                                                                                 'type': 'double'}},
                                                       'args': [('atThisPoint',
                                                                 'MPoint',
                                                                 'in'),
                                                                ('paramU',
                                                                 'double',
                                                                 'out'),
                                                                ('paramV',
                                                                 'double',
                                                                 'out'),
                                                                ('ignoreTrimBoundaries',
                                                                 'bool',
                                                                 'in'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in'),
                                                                ('tolerance',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject'),
                                                                    'tolerance': 0.001},
                                                       'deprecated': False,
                                                       'doc': '\r\nGet the parameter value corresponding to the given point on the surface (or underlying surface).',
                                                       'inArgs': ['atThisPoint',
                                                                  'ignoreTrimBoundaries',
                                                                  'space',
                                                                  'tolerance'],
                                                       'outArgs': ['paramU',
                                                                   'paramV'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'atThisPoint': ['const',
                                                                                          '&'],
                                                                          'ignoreTrimBoundaries': [],
                                                                          'paramU': ['&'],
                                                                          'paramV': ['&'],
                                                                          'space': [],
                                                                          'tolerance': []},
                                                       'types': {'atThisPoint': 'MPoint',
                                                                 'ignoreTrimBoundaries': 'bool',
                                                                 'paramU': 'double',
                                                                 'paramV': 'double',
                                                                 'space': ('MSpace',
                                                                           'Space'),
                                                                 'tolerance': 'double'}},
                                                      {'argInfo': {'atThisPoint': {'doc': '',
                                                                                   'type': 'MPoint'},
                                                                   'paramU': {'doc': '',
                                                                              'type': 'double'},
                                                                   'paramV': {'doc': '',
                                                                              'type': 'double'},
                                                                   'space': {'doc': '',
                                                                             'type': ('MSpace',
                                                                                      'Space')}},
                                                       'args': [('atThisPoint',
                                                                 'MPoint',
                                                                 'in'),
                                                                ('paramU',
                                                                 'double',
                                                                 'out'),
                                                                ('paramV',
                                                                 'double',
                                                                 'out'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject')},
                                                       'deprecated': True,
                                                       'doc': '\n This method is obsolete. \n',
                                                       'inArgs': ['atThisPoint',
                                                                  'space'],
                                                       'outArgs': ['paramU',
                                                                   'paramV'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'atThisPoint': ['const',
                                                                                          '&'],
                                                                          'paramU': ['&'],
                                                                          'paramV': ['&'],
                                                                          'space': []},
                                                       'types': {'atThisPoint': 'MPoint',
                                                                 'paramU': 'double',
                                                                 'paramV': 'double',
                                                                 'space': ('MSpace',
                                                                           'Space')}}],
                                  'getPatchUV': [{'argInfo': {'cornerIndex': {'doc': 'The patch-relative corner to examine ',
                                                                              'type': 'int'},
                                                              'patchId': {'doc': 'The patch to examine ',
                                                                          'type': 'int'},
                                                              'u': {'doc': 'storage for the u value ',
                                                                    'type': 'float'},
                                                              'v': {'doc': 'storage for the v value',
                                                                    'type': 'float'}},
                                                  'args': [('patchId',
                                                            'int',
                                                            'in'),
                                                           ('cornerIndex',
                                                            'int',
                                                            'in'),
                                                           ('u',
                                                            'float',
                                                            'out'),
                                                           ('v',
                                                            'float',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nGet the value of the specified texture coordinate for a patch corner in a patch. Since texture coordinates (uv's) are stored per-patch per-corner you must specify both the patch and the corner that the u and v values are mapped to.",
                                                  'inArgs': ['patchId',
                                                             'cornerIndex'],
                                                  'outArgs': ['u', 'v'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'cornerIndex': [],
                                                                     'patchId': [],
                                                                     'u': ['&'],
                                                                     'v': ['&']},
                                                  'types': {'cornerIndex': 'int',
                                                            'patchId': 'int',
                                                            'u': 'float',
                                                            'v': 'float'}}],
                                  'getPatchUVid': [{'argInfo': {'cornerIndex': {'doc': 'The patch-relative corner to examine (local index) ',
                                                                                'type': 'int'},
                                                                'patchId': {'doc': 'The patch to examine ',
                                                                            'type': 'int'},
                                                                'uvId': {'doc': 'storage for the uv index',
                                                                         'type': 'int'}},
                                                    'args': [('patchId',
                                                              'int',
                                                              'in'),
                                                             ('cornerIndex',
                                                              'int',
                                                              'in'),
                                                             ('uvId',
                                                              'int',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the id of the specified texture coordinate for a corner in a patch.',
                                                    'inArgs': ['patchId',
                                                               'cornerIndex'],
                                                    'outArgs': ['uvId'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'cornerIndex': [],
                                                                       'patchId': [],
                                                                       'uvId': ['&']},
                                                    'types': {'cornerIndex': 'int',
                                                              'patchId': 'int',
                                                              'uvId': 'int'}}],
                                  'getPatchUVs': [{'argInfo': {'patchId': {'doc': 'The patch to examine ',
                                                                           'type': 'int'},
                                                               'uArray': {'doc': 'storage for u values ',
                                                                          'type': 'MFloatArray'},
                                                               'vArray': {'doc': 'storage for v values',
                                                                          'type': 'MFloatArray'}},
                                                   'args': [('patchId',
                                                             'int',
                                                             'in'),
                                                            ('uArray',
                                                             'MFloatArray',
                                                             'out'),
                                                            ('vArray',
                                                             'MFloatArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the values of the texture coordinate on a specified patch. Since texture coordinates (uvs) are stored per-patch per-corner, the u and v values mapped to all corners of the specified patch are returned.',
                                                   'inArgs': ['patchId'],
                                                   'outArgs': ['uArray',
                                                               'vArray'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'patchId': [],
                                                                      'uArray': ['&'],
                                                                      'vArray': ['&']},
                                                   'types': {'patchId': 'int',
                                                             'uArray': 'MFloatArray',
                                                             'vArray': 'MFloatArray'}}],
                                  'getPointAtParam': [{'argInfo': {'paramU': {'doc': 'U parameter value ',
                                                                              'type': 'double'},
                                                                   'paramV': {'doc': 'V parameter value ',
                                                                              'type': 'double'},
                                                                   'point': {'doc': 'storage for the found point ',
                                                                             'type': 'MPoint'},
                                                                   'space': {'doc': 'Coordinate space in which to perform this operation',
                                                                             'type': ('MSpace',
                                                                                      'Space')}},
                                                       'args': [('paramU',
                                                                 'double',
                                                                 'in'),
                                                                ('paramV',
                                                                 'double',
                                                                 'in'),
                                                                ('point',
                                                                 'MPoint',
                                                                 'out'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject')},
                                                       'deprecated': False,
                                                       'doc': '\r\nFinds the point corresponding to the given parameter value on the surface.',
                                                       'inArgs': ['paramU',
                                                                  'paramV',
                                                                  'space'],
                                                       'outArgs': ['point'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'paramU': [],
                                                                          'paramV': [],
                                                                          'point': ['&'],
                                                                          'space': []},
                                                       'types': {'paramU': 'double',
                                                                 'paramV': 'double',
                                                                 'point': 'MPoint',
                                                                 'space': ('MSpace',
                                                                           'Space')}}],
                                  'getTangents': [{'argInfo': {'paramInU': {'doc': 'U parameter value at which to obtain tangents ',
                                                                            'type': 'double'},
                                                               'paramInV': {'doc': 'V parameter value at which to obtain tangents ',
                                                                            'type': 'double'},
                                                               'space': {'doc': 'Coordinate space for the returned vectors',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'vectorInU': {'doc': 'Storage for the U tangent vector ',
                                                                             'type': 'MVector'},
                                                               'vectorInV': {'doc': 'Storage for the V tangent vector ',
                                                                             'type': 'MVector'}},
                                                   'args': [('paramInU',
                                                             'double',
                                                             'in'),
                                                            ('paramInV',
                                                             'double',
                                                             'in'),
                                                            ('vectorInU',
                                                             'MVector',
                                                             'out'),
                                                            ('vectorInV',
                                                             'MVector',
                                                             'out'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject')},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieve the tangents in the U and V directions at the given parameter value on the surface. The returned tangent vectors are normalized.',
                                                   'inArgs': ['paramInU',
                                                              'paramInV',
                                                              'space'],
                                                   'outArgs': ['vectorInU',
                                                               'vectorInV'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'paramInU': [],
                                                                      'paramInV': [],
                                                                      'space': [],
                                                                      'vectorInU': ['&'],
                                                                      'vectorInV': ['&']},
                                                   'types': {'paramInU': 'double',
                                                             'paramInV': 'double',
                                                             'space': ('MSpace',
                                                                       'Space'),
                                                             'vectorInU': 'MVector',
                                                             'vectorInV': 'MVector'}}],
                                  'getTrimBoundaries': [{'argInfo': {'paramEdge': {'doc': 'If true, then 2D curves are returned, otherwise 3D curves.',
                                                                                   'type': 'bool'},
                                                                     'region': {'doc': 'the trimmed region containing the boundaries ',
                                                                                'type': 'uint'},
                                                                     'result': {'doc': 'All trim boundaries of the given region in this surface. ',
                                                                                'type': 'MTrimBoundaryArray'}},
                                                         'args': [('result',
                                                                   'MTrimBoundaryArray',
                                                                   'out'),
                                                                  ('region',
                                                                   'uint',
                                                                   'in'),
                                                                  ('paramEdge',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {'paramEdge': True},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns all trim boundaries of a region on this surface.',
                                                         'inArgs': ['region',
                                                                    'paramEdge'],
                                                         'outArgs': ['result'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'paramEdge': [],
                                                                            'region': ['unsigned'],
                                                                            'result': ['&']},
                                                         'types': {'paramEdge': 'bool',
                                                                   'region': 'uint',
                                                                   'result': 'MTrimBoundaryArray'}}],
                                  'getUV': [{'argInfo': {'u': {'doc': 'storage for the u value ',
                                                               'type': 'float'},
                                                         'uvId': {'doc': 'the element in the uv list to examine ',
                                                                  'type': 'int'},
                                                         'v': {'doc': 'storage for the v value',
                                                               'type': 'float'}},
                                             'args': [('uvId',
                                                       'int',
                                                       'in'),
                                                      ('u',
                                                       'float',
                                                       'out'),
                                                      ('v',
                                                       'float',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nGet the value of the specified texture coordinate from this surface's uv list. The uvId is the element in the uv list that will be retrieved.",
                                             'inArgs': ['uvId'],
                                             'inverse': ('setUV', False),
                                             'outArgs': ['u', 'v'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'u': ['&'],
                                                                'uvId': [],
                                                                'v': ['&']},
                                             'types': {'u': 'float',
                                                       'uvId': 'int',
                                                       'v': 'float'}}],
                                  'getUVs': [{'argInfo': {'uArray': {'doc': 'Storage for the u texture coordinate list ',
                                                                     'type': 'MFloatArray'},
                                                          'vArray': {'doc': 'Storage for the v texture coordinate list',
                                                                     'type': 'MFloatArray'}},
                                              'args': [('uArray',
                                                        'MFloatArray',
                                                        'out'),
                                                       ('vArray',
                                                        'MFloatArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method copies the texture coordinate list for this surface into the given uv arrays.',
                                              'inArgs': [],
                                              'inverse': ('setUVs',
                                                          False),
                                              'outArgs': ['uArray',
                                                          'vArray'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'uArray': ['&'],
                                                                 'vArray': ['&']},
                                              'types': {'uArray': 'MFloatArray',
                                                        'vArray': 'MFloatArray'}}],
                                  'hasHistoryOnCreate': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis method determines if the shape was created with history.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Boolean value: true if the shape has history, false otherwise.',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                  'intersect': [{'argInfo': {'alongThisDirection': {'doc': 'Direction of ray to test. ',
                                                                                    'type': 'MVector'},
                                                             'calculateDistance': {'doc': 'Specifies whether to calculate the distance of the startPoint to the point of intersection ',
                                                                                   'type': 'bool'},
                                                             'calculateExactHit': {'doc': 'Specifies whether to determine if the point of intersection actually hit the object or just came within tolerance of it. ',
                                                                                   'type': 'bool'},
                                                             'distance': {'doc': "Distance of intersection point from startPoint. Ignored if 'calculateDistance' is false. ",
                                                                          'type': 'double'},
                                                             'pntOfIntersection': {'doc': 'Closest point of intersection (if any). ',
                                                                                   'type': 'MPoint'},
                                                             'rayStartingPoint': {'doc': 'Starting location of ray to test. ',
                                                                                  'type': 'MPoint'},
                                                             'space': {'doc': 'Specifies the coordinate system for this operation. ',
                                                                       'type': ('MSpace',
                                                                                'Space')},
                                                             'tolerance': {'doc': 'The epsilon value in the calculation. ',
                                                                           'type': 'double'},
                                                             'u': {'doc': 'U parameter of intersection (if any). ',
                                                                   'type': 'double'},
                                                             'v': {'doc': 'V parameter of intersection (if any). ',
                                                                   'type': 'double'},
                                                             'wasExactHit': {'doc': "Returns true if the point of intersection is an exact hit, false otherwise. Ignored if 'calculateExactHit' if false. ",
                                                                             'type': 'bool'}},
                                                 'args': [('rayStartingPoint',
                                                           'MPoint',
                                                           'in'),
                                                          ('alongThisDirection',
                                                           'MVector',
                                                           'in'),
                                                          ('u',
                                                           'double',
                                                           'out'),
                                                          ('v',
                                                           'double',
                                                           'out'),
                                                          ('pntOfIntersection',
                                                           'MPoint',
                                                           'out'),
                                                          ('tolerance',
                                                           'double',
                                                           'in'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in'),
                                                          ('calculateDistance',
                                                           'bool',
                                                           'in'),
                                                          ('distance',
                                                           'double',
                                                           'out'),
                                                          ('calculateExactHit',
                                                           'bool',
                                                           'in'),
                                                          ('wasExactHit',
                                                           'bool',
                                                           'out')],
                                                 'defaults': {'calculateDistance': False,
                                                              'calculateExactHit': False,
                                                              'distance': None,
                                                              'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject'),
                                                              'tolerance': 0.001,
                                                              'wasExactHit': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis function determines the closest point of intersection of this spline surface with a ray (a vector at a point).',
                                                 'inArgs': ['rayStartingPoint',
                                                            'alongThisDirection',
                                                            'tolerance',
                                                            'space',
                                                            'calculateDistance',
                                                            'calculateExactHit'],
                                                 'outArgs': ['u',
                                                             'v',
                                                             'pntOfIntersection',
                                                             'distance',
                                                             'wasExactHit'],
                                                 'returnInfo': {'doc': 'Boolean value: true if an intersection point has been found, false otherwise.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'alongThisDirection': ['const',
                                                                                           '&'],
                                                                    'calculateDistance': [],
                                                                    'calculateExactHit': [],
                                                                    'distance': ['*'],
                                                                    'pntOfIntersection': ['&'],
                                                                    'rayStartingPoint': ['const',
                                                                                         '&'],
                                                                    'space': [],
                                                                    'tolerance': [],
                                                                    'u': ['&'],
                                                                    'v': ['&'],
                                                                    'wasExactHit': ['*']},
                                                 'types': {'alongThisDirection': 'MVector',
                                                           'calculateDistance': 'bool',
                                                           'calculateExactHit': 'bool',
                                                           'distance': 'double',
                                                           'pntOfIntersection': 'MPoint',
                                                           'rayStartingPoint': 'MPoint',
                                                           'space': ('MSpace',
                                                                     'Space'),
                                                           'tolerance': 'double',
                                                           'u': 'double',
                                                           'v': 'double',
                                                           'wasExactHit': 'bool'}},
                                                {'argInfo': {'alongThisDirection': {'doc': 'Direction of ray to test. ',
                                                                                    'type': 'MVector'},
                                                             'calculateDistance': {'doc': 'Specifies whether to calculate the distances of the startPoint to the all the points of intersection. ',
                                                                                   'type': 'bool'},
                                                             'calculateExactHit': {'doc': 'Specifies whether to determine if the point of intersection actually hit the object or just came within tolerance of it. ',
                                                                                   'type': 'bool'},
                                                             'distances': {'doc': "Distances of intersection points from startPoint. Ignored if 'calculateDistance' is false. ",
                                                                           'type': 'MDoubleArray'},
                                                             'points': {'doc': 'Points of intersection. ',
                                                                        'type': 'MPointArray'},
                                                             'rayStartingPoint': {'doc': 'Starting location of ray to test. ',
                                                                                  'type': 'MPoint'},
                                                             'space': {'doc': 'Specifies the coordinate system for this operation. ',
                                                                       'type': ('MSpace',
                                                                                'Space')},
                                                             'tolerance': {'doc': 'The epsilon value in the calculation. ',
                                                                           'type': 'double'},
                                                             'uArray': {'doc': 'U parameters of intersections. ',
                                                                        'type': 'MDoubleArray'},
                                                             'vArray': {'doc': 'V parameters of intersections. ',
                                                                        'type': 'MDoubleArray'},
                                                             'wasExactHit': {'doc': "Returns true if the point of intersection is an exact hit, false otherwise. Ignored if 'calculateExactHit' if false. ",
                                                                             'type': 'bool'}},
                                                 'args': [('rayStartingPoint',
                                                           'MPoint',
                                                           'in'),
                                                          ('alongThisDirection',
                                                           'MVector',
                                                           'in'),
                                                          ('uArray',
                                                           'MDoubleArray',
                                                           'out'),
                                                          ('vArray',
                                                           'MDoubleArray',
                                                           'out'),
                                                          ('points',
                                                           'MPointArray',
                                                           'out'),
                                                          ('tolerance',
                                                           'double',
                                                           'in'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in'),
                                                          ('calculateDistance',
                                                           'bool',
                                                           'in'),
                                                          ('distances',
                                                           'MDoubleArray',
                                                           'out'),
                                                          ('calculateExactHit',
                                                           'bool',
                                                           'in'),
                                                          ('wasExactHit',
                                                           'bool',
                                                           'out')],
                                                 'defaults': {'calculateDistance': False,
                                                              'calculateExactHit': False,
                                                              'distances': None,
                                                              'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject'),
                                                              'tolerance': 0.001,
                                                              'wasExactHit': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis function determines all the points of intersection of this spline surface with a ray (a vector at a point).',
                                                 'inArgs': ['rayStartingPoint',
                                                            'alongThisDirection',
                                                            'tolerance',
                                                            'space',
                                                            'calculateDistance',
                                                            'calculateExactHit'],
                                                 'outArgs': ['uArray',
                                                             'vArray',
                                                             'points',
                                                             'distances',
                                                             'wasExactHit'],
                                                 'returnInfo': {'doc': 'Boolean value: true if an intersection point has been found, false otherwise.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'alongThisDirection': ['const',
                                                                                           '&'],
                                                                    'calculateDistance': [],
                                                                    'calculateExactHit': [],
                                                                    'distances': ['*'],
                                                                    'points': ['&'],
                                                                    'rayStartingPoint': ['const',
                                                                                         '&'],
                                                                    'space': [],
                                                                    'tolerance': [],
                                                                    'uArray': ['&'],
                                                                    'vArray': ['&'],
                                                                    'wasExactHit': ['*']},
                                                 'types': {'alongThisDirection': 'MVector',
                                                           'calculateDistance': 'bool',
                                                           'calculateExactHit': 'bool',
                                                           'distances': 'MDoubleArray',
                                                           'points': 'MPointArray',
                                                           'rayStartingPoint': 'MPoint',
                                                           'space': ('MSpace',
                                                                     'Space'),
                                                           'tolerance': 'double',
                                                           'uArray': 'MDoubleArray',
                                                           'vArray': 'MDoubleArray',
                                                           'wasExactHit': 'bool'}}],
                                  'isBezier': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermine if the knot spacing gives us Bezier surface.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' true Bezier surface  false B-spline surface  ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                  'isFlipNorm': [{'argInfo': {'region': {'doc': 'Trimmed region to check. Must be in the range 0 to numRegions() - 1. ',
                                                                         'type': 'uint'}},
                                                  'args': [('region',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDetermines whether the normal for the specified region is flipped. This method is only valid for trimmed surfaces.',
                                                  'inArgs': ['region'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' true normal = -dS/du X dS/dv  false normal = dS/du X dS/dv  ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'region': ['unsigned']},
                                                  'types': {'region': 'uint'}}],
                                  'isFoldedOnBispan': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nEvaluate the surface to determine if it contains any folds or creases. The entire surface including trimmed regions is examined. This function will only check for folds on bispan boundaries and thus will not catch all cases.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                  'isKnotU': [{'argInfo': {'param': {'doc': 'parameter value to test ',
                                                                     'type': 'double'}},
                                               'args': [('param',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nCheck if the specified parameter value is a knot value.',
                                               'inArgs': ['param'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if the parameter value is a knot value, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'param': []},
                                               'types': {'param': 'double'}}],
                                  'isKnotV': [{'argInfo': {'param': {'doc': 'parameter value to test ',
                                                                     'type': 'double'}},
                                               'args': [('param',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nCheck if the specified parameter value is a knot value.',
                                               'inArgs': ['param'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if the parameter value is a knot value, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'param': []},
                                               'types': {'param': 'double'}}],
                                  'isParamOnSurface': [{'argInfo': {'paramU': {'doc': 'U parameter value ',
                                                                               'type': 'double'},
                                                                    'paramV': {'doc': 'V parameter value ',
                                                                               'type': 'double'}},
                                                        'args': [('paramU',
                                                                  'double',
                                                                  'in'),
                                                                 ('paramV',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nCheck if the specified parameter is on this surface.',
                                                        'inArgs': ['paramU',
                                                                   'paramV'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Boolean value: true if the parameter value on this surface, false otherwise.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'paramU': [],
                                                                           'paramV': []},
                                                        'types': {'paramU': 'double',
                                                                  'paramV': 'double'}}],
                                  'isPointInTrimmedRegion': [{'argInfo': {'u': {'doc': 'u parameter of point on surface to test ',
                                                                                'type': 'double'},
                                                                          'v': {'doc': 'v parameter of point on surface to test ',
                                                                                'type': 'double'}},
                                                              'args': [('u',
                                                                        'double',
                                                                        'in'),
                                                                       ('v',
                                                                        'double',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns true if the given point is in a trimmed away region of a trimmed surface. A trimmed away region is the part of the surface that is cut away as a result of a trim operation.',
                                                              'inArgs': ['u',
                                                                         'v'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'Boolean value: true if the point on surface is within a trimmed away region, false otherwise.',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'u': [],
                                                                                 'v': []},
                                                              'types': {'u': 'double',
                                                                        'v': 'double'}}],
                                  'isPointOnSurface': [{'argInfo': {'point': {'doc': 'Point to test ',
                                                                              'type': 'MPoint'},
                                                                    'space': {'doc': 'Coordinate space for this operation ',
                                                                              'type': ('MSpace',
                                                                                       'Space')},
                                                                    'tolerance': {'doc': 'tolerance value to be used for computations ',
                                                                                  'type': 'double'}},
                                                        'args': [('point',
                                                                  'MPoint',
                                                                  'in'),
                                                                 ('tolerance',
                                                                  'double',
                                                                  'in'),
                                                                 ('space',
                                                                  ('MSpace',
                                                                   'Space'),
                                                                  'in')],
                                                        'defaults': {'space': ('MSpace',
                                                                               'Space',
                                                                               'kObject'),
                                                                     'tolerance': 0.001},
                                                        'deprecated': False,
                                                        'doc': '\r\nCheck if the given point is on this surface.',
                                                        'inArgs': ['point',
                                                                   'tolerance',
                                                                   'space'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Boolean value: true if the given point is on this surface, false otherwise.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'point': ['const',
                                                                                     '&'],
                                                                           'space': [],
                                                                           'tolerance': []},
                                                        'types': {'point': 'MPoint',
                                                                  'space': ('MSpace',
                                                                            'Space'),
                                                                  'tolerance': 'double'}}],
                                  'isTrimmedSurface': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method determines if this surface is a trimmed surface.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Boolean value: true if the surface is trimmed, false otherwise.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                  'isUniform': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nDetermine if the knot spacing is uniform.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true Uniform knot spacing  false Non-uniform knot spacing  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                  'knotInU': [{'argInfo': {'index': {'doc': 'The U index of the knot value to get ',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRetrieve the given knot value from this surface at the specified U index. U knots are indexed from 0 to  numKnotsInU() -1.',
                                               'inArgs': ['index'],
                                               'inverse': ('setKnotInU',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The knot value',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                                  'knotInV': [{'argInfo': {'index': {'doc': 'The V index of the knot value to get ',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRetrieve the given knot value from this surface at the specified V index. V knots are indexed from 0 to  numKnotsInV() -1.',
                                               'inArgs': ['index'],
                                               'inverse': ('setKnotInV',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The knot value',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                                  'normal': [{'argInfo': {'paramInU': {'doc': 'U parameter at which to obtain normal ',
                                                                       'type': 'double'},
                                                          'paramInV': {'doc': 'V parameter at which to obtain normal ',
                                                                       'type': 'double'},
                                                          'space': {'doc': 'Coordinate space for the returned vector ',
                                                                    'type': ('MSpace',
                                                                             'Space')}},
                                              'args': [('paramInU',
                                                        'double',
                                                        'in'),
                                                       ('paramInV',
                                                        'double',
                                                        'in'),
                                                       ('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': '\r\nRetrieve the normal at the given parameter value on the surface.',
                                              'inArgs': ['paramInU',
                                                         'paramInV',
                                                         'space'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The normal vector',
                                                             'qualifiers': [],
                                                             'type': 'MVector'},
                                              'returnType': 'MVector',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'paramInU': [],
                                                                 'paramInV': [],
                                                                 'space': []},
                                              'types': {'paramInU': 'double',
                                                        'paramInV': 'double',
                                                        'space': ('MSpace',
                                                                  'Space')}}],
                                  'numBoundaries': [{'argInfo': {'region': {'doc': 'The trimmed region to examine ',
                                                                            'type': 'uint'}},
                                                     'args': [('region',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the number of boundaries for the specified region. The surface must be a trimmed surface.',
                                                     'inArgs': ['region'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The number of boundaries for the specified region',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'region': ['unsigned']},
                                                     'types': {'region': 'uint'}}],
                                  'numCVsInU': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the number of CVs in the U direction (degree + spans).',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of CVs in U',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                  'numCVsInV': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the number of CVs in the V direction (degree + spans).',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of CVs in V',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                  'numEdges': [{'argInfo': {'boundary': {'doc': 'Boundary to examine ',
                                                                         'type': 'uint'},
                                                            'region': {'doc': 'Region to examine ',
                                                                       'type': 'uint'}},
                                                'args': [('region',
                                                          'uint',
                                                          'in'),
                                                         ('boundary',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the number of edges for the specified trim boundary.',
                                                'inArgs': ['region',
                                                           'boundary'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of edges for the specified boundary',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'boundary': ['unsigned'],
                                                                   'region': ['unsigned']},
                                                'types': {'boundary': 'uint',
                                                          'region': 'uint'}}],
                                  'numKnotsInU': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the number of knots in U including multiple end knots (spans + 2 * degree - 1).',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The number of knots in U',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                  'numKnotsInV': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the number of knots in V including multiple end knots (spans + 2 * degree - 1).',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The number of knots in V',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                  'numNonZeroSpansInU': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns the number of non-zero spans in the U direction. This value will be equivalent to the value returned by  numSpansInU()  if all of the internal (non-end) knots are of multiplicity 1. If some of the internal knots have higher multiplicity, this value will be lower than that returned by  numSpansInU() . You can use the number of non-zero spans to count the number of  visual  spans on the surface in the U direction, since the empty (zero) spans do not appear as a separate span/patch in the display.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The number of non-empty (non-zero, visual) spans in U',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                  'numNonZeroSpansInV': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns the number of non-zero spans in the V direction. This value will be equivalent to the value returned by  numSpansInV()  if all of the internal (non-end) knots are of multiplicity 1. If some of the internal knots have higher multiplicity, this value will be lower than that returned by  numSpansInV() . You can use the number of non-zero spans to count the number of  visual  spans on the surface in the V direction, since the empty (zero) spans do not appear as a separate span/patch in the display.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The number of non-empty (non-zero, visual) spans in V',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                  'numPatches': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the number of non-zero patches in this surface.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The number of non-zero patches in this surface.',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                  'numPatchesInU': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the number of non-zero patches along u, in this surface.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The number of non-zero patches along u, in this surface.',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                  'numPatchesInV': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the number of non-zero patches along v, in this surface.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The number of non-zero patches along v, in this surface.',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                  'numRegions': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the number of trimmed regions for this surface or 0 if the surface is not a trimmed surface.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The number of regions for this surface',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                  'numSpansInU': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the number of spans in the u direction.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The number of spans in U',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                  'numSpansInV': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the number of spans in the v direction.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The number of spans in V',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                  'numUVs': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\r\nReturns the number of texture (uv) coordinates for this surface. The uv's are stored in a list which is referenced by patches requiring textures on a per-patch per-patchCorner basis. This method returns the number of elements in this list.",
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The number of texture coordinates',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                  'projectCurve': [{'argInfo': {'constructionHistory': {'doc': 'keep construction history',
                                                                                        'type': 'bool'},
                                                                'curve': {'doc': 'curve to be projected ',
                                                                          'type': 'MDagPath'},
                                                                'direction': {'doc': 'direction of projection. If this is null then the surface normals is used ',
                                                                              'type': 'MVector'}},
                                                    'args': [('curve',
                                                              'MDagPath',
                                                              'in'),
                                                             ('direction',
                                                              'MVector',
                                                              'in'),
                                                             ('constructionHistory',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {'constructionHistory': False,
                                                                 'direction': None},
                                                    'deprecated': False,
                                                    'doc': '\r\nProject the given curve onto this surface creating a curve on surface. Projection will be done using the surface normals unless a direction vector to project along is given.',
                                                    'inArgs': ['curve',
                                                               'direction',
                                                               'constructionHistory'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'constructionHistory': [],
                                                                       'curve': ['const',
                                                                                 '&'],
                                                                       'direction': ['const',
                                                                                     '*']},
                                                    'types': {'constructionHistory': 'bool',
                                                              'curve': 'MDagPath',
                                                              'direction': 'MVector'}}],
                                  'removeKnotInU': [{'argInfo': {'atThisParam': {'doc': 'Parameter of knot to be removed ',
                                                                                 'type': 'double'},
                                                                 'removeAll': {'doc': 'If true then remove all the knots at the given parameter, otherwise remove all except one knot',
                                                                               'type': 'bool'}},
                                                     'args': [('atThisParam',
                                                               'double',
                                                               'in'),
                                                              ('removeAll',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {'removeAll': False},
                                                     'deprecated': False,
                                                     'doc': '\r\nRemove the U knot(s) at the specified parameter value from this surface. If there are multiple knots at this parameter then removeAll is used to specify how to do the removal.',
                                                     'inArgs': ['atThisParam',
                                                                'removeAll'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'atThisParam': [],
                                                                        'removeAll': []},
                                                     'types': {'atThisParam': 'double',
                                                               'removeAll': 'bool'}}],
                                  'removeKnotInV': [{'argInfo': {'atThisParam': {'doc': 'Parameter of knot to be removed ',
                                                                                 'type': 'double'},
                                                                 'removeAll': {'doc': 'If true then remove all the knots at the given parameter, otherwise remove all except one knot',
                                                                               'type': 'bool'}},
                                                     'args': [('atThisParam',
                                                               'double',
                                                               'in'),
                                                              ('removeAll',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {'removeAll': False},
                                                     'deprecated': False,
                                                     'doc': '\r\nRemove the V knot(s) at the specified parameter value from this surface. If there are multiple knots at this parameter then removeAll is used to specify how to do the removal.',
                                                     'inArgs': ['atThisParam',
                                                                'removeAll'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'atThisParam': [],
                                                                        'removeAll': []},
                                                     'types': {'atThisParam': 'double',
                                                               'removeAll': 'bool'}}],
                                  'removeOneKnotInU': [{'argInfo': {'atThisParam': {'doc': 'Parameter of knot to be removed',
                                                                                    'type': 'double'}},
                                                        'args': [('atThisParam',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRemove one U knot at the specified parameter value from this surface.',
                                                        'inArgs': ['atThisParam'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'atThisParam': []},
                                                        'types': {'atThisParam': 'double'}}],
                                  'removeOneKnotInV': [{'argInfo': {'atThisParam': {'doc': 'Parameter of knot to be removed',
                                                                                    'type': 'double'}},
                                                        'args': [('atThisParam',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRemove one V knot at the specified parameter value from this surface.',
                                                        'inArgs': ['atThisParam'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'atThisParam': []},
                                                        'types': {'atThisParam': 'double'}}],
                                  'setCV': [{'argInfo': {'indexU': {'doc': 'U index of CV ',
                                                                    'type': 'uint'},
                                                         'indexV': {'doc': 'V index of CV ',
                                                                    'type': 'uint'},
                                                         'pt': {'doc': 'new location for the CV ',
                                                                'type': 'MPoint'},
                                                         'space': {'doc': 'coordinate space for the CV',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('indexU',
                                                       'uint',
                                                       'in'),
                                                      ('indexV',
                                                       'uint',
                                                       'in'),
                                                      ('pt',
                                                       'MPoint',
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nSet the location of the specified CV.',
                                             'inArgs': ['indexU',
                                                        'indexV',
                                                        'pt',
                                                        'space'],
                                             'inverse': ('getCV', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'indexU': ['unsigned'],
                                                                'indexV': ['unsigned'],
                                                                'pt': ['&'],
                                                                'space': []},
                                             'types': {'indexU': 'uint',
                                                       'indexV': 'uint',
                                                       'pt': 'MPoint',
                                                       'space': ('MSpace',
                                                                 'Space')}}],
                                  'setCVs': [{'argInfo': {'array': {'doc': 'The array of point values of the CVs ',
                                                                    'type': 'MPointArray'},
                                                          'space': {'doc': 'specifies the coordinate system for this operation',
                                                                    'type': ('MSpace',
                                                                             'Space')}},
                                              'args': [('array',
                                                        'MPointArray',
                                                        'in'),
                                                       ('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': '\r\nSet the CVs for this surface to the given points.  numCVsInU()  *  numCVsInV()  points must be provided. Converting from uIndex, vIndex is done by "index = numCVsInV() * uIndex + vIndex".',
                                              'inArgs': ['array',
                                                         'space'],
                                              'inverse': ('getCVs', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['const',
                                                                           '&'],
                                                                 'space': []},
                                              'types': {'array': 'MPointArray',
                                                        'space': ('MSpace',
                                                                  'Space')}}],
                                  'setKnotInU': [{'argInfo': {'index': {'doc': 'The U index of the existing knot to be set ',
                                                                        'type': 'uint'},
                                                              'param': {'doc': 'The new parameter value for the knot',
                                                                        'type': 'double'}},
                                                  'args': [(u'index',
                                                            'int',
                                                            'in'),
                                                           (u'param',
                                                            'double',
                                                            u'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the value of the given existing knot at the specified U index. U knots are indexed from 0 to  numKnotsInU() -1. Note that this method does not insert a new knot, it simply changes the value of a knot that already exists.',
                                                  'inArgs': [u'index',
                                                             u'param'],
                                                  'inverse': ('knotInU',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned'],
                                                                     'param': []},
                                                  'types': {'index': 'uint',
                                                            'param': 'double'}}],
                                  'setKnotInV': [{'argInfo': {'index': {'doc': 'The V index of the existing knot to be set ',
                                                                        'type': 'uint'},
                                                              'param': {'doc': 'The new value for the knot',
                                                                        'type': 'double'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in'),
                                                           ('param',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the value of the given existing knot at the specified V index. V knots are indexed from 0 to  numKnotsInV() -1. Note that this routine does not insert a new knot, it simply changes the value of a knot that already exists.',
                                                  'inArgs': ['index',
                                                             'param'],
                                                  'inverse': ('knotInV',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned'],
                                                                     'param': []},
                                                  'types': {'index': 'uint',
                                                            'param': 'double'}}],
                                  'setKnotsInU': [{'argInfo': {'array': {'doc': 'The knot values to be set ',
                                                                         'type': 'MDoubleArray'},
                                                               'endIndex': {'doc': 'The end knot index',
                                                                            'type': 'uint'},
                                                               'startIndex': {'doc': 'The start knot index ',
                                                                              'type': 'uint'}},
                                                   'args': [('array',
                                                             'MDoubleArray',
                                                             'in'),
                                                            ('startIndex',
                                                             'uint',
                                                             'in'),
                                                            ('endIndex',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the specified U knot values for this surface.',
                                                   'inArgs': ['array',
                                                              'startIndex',
                                                              'endIndex'],
                                                   'inverse': ('getKnotsInU',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'array': ['const',
                                                                                '&'],
                                                                      'endIndex': ['unsigned'],
                                                                      'startIndex': ['unsigned']},
                                                   'types': {'array': 'MDoubleArray',
                                                             'endIndex': 'uint',
                                                             'startIndex': 'uint'}}],
                                  'setKnotsInV': [{'argInfo': {'array': {'doc': 'The knot values to be set ',
                                                                         'type': 'MDoubleArray'},
                                                               'endIndex': {'doc': 'The end knot index',
                                                                            'type': 'uint'},
                                                               'startIndex': {'doc': 'The start knot index ',
                                                                              'type': 'uint'}},
                                                   'args': [('array',
                                                             'MDoubleArray',
                                                             'in'),
                                                            ('startIndex',
                                                             'uint',
                                                             'in'),
                                                            ('endIndex',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the specified V knot values for this surface.',
                                                   'inArgs': ['array',
                                                              'startIndex',
                                                              'endIndex'],
                                                   'inverse': ('getKnotsInV',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'array': ['const',
                                                                                '&'],
                                                                      'endIndex': ['unsigned'],
                                                                      'startIndex': ['unsigned']},
                                                   'types': {'array': 'MDoubleArray',
                                                             'endIndex': 'uint',
                                                             'startIndex': 'uint'}}],
                                  'setUV': [{'argInfo': {'u': {'doc': 'the new u value that is to be set ',
                                                               'type': 'float'},
                                                         'uvId': {'doc': 'the element in the uv list to be set ',
                                                                  'type': 'int'},
                                                         'v': {'doc': 'the new v value that is to be set',
                                                               'type': 'float'}},
                                             'args': [('uvId',
                                                       'int',
                                                       'in'),
                                                      ('u',
                                                       'float',
                                                       'in'),
                                                      ('v',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the specified texture coordinate. The uvId is the element in the uv list that will be set. If the uvId is greater than or equal to  numUVs()  then the uv list will be grown to accommodate the specified uv.',
                                             'inArgs': ['uvId', 'u', 'v'],
                                             'inverse': ('getUV', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'u': [],
                                                                'uvId': [],
                                                                'v': []},
                                             'types': {'u': 'float',
                                                       'uvId': 'int',
                                                       'v': 'float'}}],
                                  'setUVs': [{'argInfo': {'uArray': {'doc': 'The array of u values to be set ',
                                                                     'type': 'MFloatArray'},
                                                          'vArray': {'doc': 'The array of v values to be set',
                                                                     'type': 'MFloatArray'}},
                                              'args': [('uArray',
                                                        'MFloatArray',
                                                        'in'),
                                                       ('vArray',
                                                        'MFloatArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets all of the texture coordinates (uvs) for this surface. The uv arrays must be of equal size and must be at least of length  numUVs() . If the arrays are larger than  numUVs()  then the uv list for this surface will be grown to accommodate the new uv values.',
                                              'inArgs': ['uArray',
                                                         'vArray'],
                                              'inverse': ('getUVs', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'uArray': ['const',
                                                                            '&'],
                                                                 'vArray': ['const',
                                                                            '&']},
                                              'types': {'uArray': 'MFloatArray',
                                                        'vArray': 'MFloatArray'}}],
                                  'tesselate': [{'argInfo': {'parentOrOwner': {'doc': 'the DAG parent or kMeshData the new mesh will belong to ',
                                                                               'type': 'MObject'},
                                                             'parms': {'doc': 'Tesselation parameters ',
                                                                       'type': 'MTesselationParams'}},
                                                 'args': [('parms',
                                                           'MTesselationParams',
                                                           'in'),
                                                          ('parentOrOwner',
                                                           'MObject',
                                                           'in')],
                                                 'defaults': {'parentOrOwner': 'MObject::kNullObj',
                                                              'parms': 'MTesselationParams::fsDefaultTesselationParams'},
                                                 'deprecated': False,
                                                 'doc': '\r\nPerforms tesselation on this surface and create a new mesh in the DAG. The type of tesselation can be controlled by providing the tesselation parameters (see  MTesselationParams ).',
                                                 'inArgs': ['parms',
                                                            'parentOrOwner'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' If parentOrOwner is nullptr then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'parentOrOwner': [],
                                                                    'parms': ['&']},
                                                 'types': {'parentOrOwner': 'MObject',
                                                           'parms': 'MTesselationParams'}},
                                                {'argInfo': {'parms': {'doc': 'Tesselation parameters ',
                                                                       'type': 'MTesselationParams'}},
                                                 'args': [('parms',
                                                           'MTesselationParams',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': True,
                                                 'doc': '\n This method is obsolete. \n',
                                                 'inArgs': ['parms'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A polygonal representation of this surface',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'parms': ['&']},
                                                 'types': {'parms': 'MTesselationParams'}}],
                                  'trim': [{'argInfo': {'constructionHistory': {'doc': 'keep construction history',
                                                                                'type': 'bool'},
                                                        'locatorU': {'doc': 'array of U parameters indicating regions to keep ',
                                                                     'type': 'MDoubleArray'},
                                                        'locatorV': {'doc': 'array of V parameters indicating regions to keep ',
                                                                     'type': 'MDoubleArray'}},
                                            'args': [('locatorU',
                                                      'MDoubleArray',
                                                      'in'),
                                                     ('locatorV',
                                                      'MDoubleArray',
                                                      'in'),
                                                     ('constructionHistory',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'constructionHistory': False},
                                            'deprecated': False,
                                            'doc': '\r\nTrim this surface to its curves on surface. Regions which are kept are specified by passing in two arrays of u,v parameters.',
                                            'inArgs': ['locatorU',
                                                       'locatorV',
                                                       'constructionHistory'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'constructionHistory': [],
                                                               'locatorU': ['const',
                                                                            '&'],
                                                               'locatorV': ['const',
                                                                            '&']},
                                            'types': {'constructionHistory': 'bool',
                                                      'locatorU': 'MDoubleArray',
                                                      'locatorV': 'MDoubleArray'}}],
                                  'trimWithBoundaries': [{'argInfo': {'createNewRegion': {'doc': 'Whether to create a new region on the trimmed surface. A region is a disjoint area of a trimmed surface.',
                                                                                          'type': 'bool'},
                                                                      'e_tol': {'doc': 'The 3d edge tolerance with which to trim ',
                                                                                'type': 'double'},
                                                                      'flipNormal': {'doc': 'Whether to flip the trimmed surface normal ',
                                                                                     'type': 'bool'},
                                                                      'mBoundaries': {'doc': 'The boundaries used for the trim. A boundary may consist of several curves. They must present a closed boundary, must be in UV (parameter) space, and must be on the surface. Boundaries[0] is the outer boundary which goes counterclockwise around the surface normal. All other boundaries must be inner boundaries inside the outer boundary defined region. A clockwise inner boundary defines a hole. Boundaries[0] can be empty. In this case, the native boundary is used as outer boundary. The boundaries should not intersect each other or themselves. ',
                                                                                      'type': 'MTrimBoundaryArray'},
                                                                      'pe_tol': {'doc': 'The parameter edge tolerance with which to trim ',
                                                                                 'type': 'double'}},
                                                          'args': [('mBoundaries',
                                                                    'MTrimBoundaryArray',
                                                                    'in'),
                                                                   ('flipNormal',
                                                                    'bool',
                                                                    'in'),
                                                                   ('e_tol',
                                                                    'double',
                                                                    'in'),
                                                                   ('pe_tol',
                                                                    'double',
                                                                    'in'),
                                                                   ('createNewRegion',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {'createNewRegion': False,
                                                                       'e_tol': 0.001,
                                                                       'flipNormal': False,
                                                                       'pe_tol': 1e-05},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis function trims this surface with given trim boundaries.',
                                                          'inArgs': ['mBoundaries',
                                                                     'flipNormal',
                                                                     'e_tol',
                                                                     'pe_tol',
                                                                     'createNewRegion'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'createNewRegion': [],
                                                                             'e_tol': [],
                                                                             'flipNormal': [],
                                                                             'mBoundaries': ['const',
                                                                                             '&'],
                                                                             'pe_tol': []},
                                                          'types': {'createNewRegion': 'bool',
                                                                    'e_tol': 'double',
                                                                    'flipNormal': 'bool',
                                                                    'mBoundaries': 'MTrimBoundaryArray',
                                                                    'pe_tol': 'double'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nFunction set type. \r\n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                  'updateSurface': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method signals that this surface has changed and needs to be recalculated.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}]},
                      'pymelEnums': {'BoundaryType': "Enum('BoundaryType', [('invalidBoundary', 0), ('kInvalidBoundary', 0), ('outer', 1), ('kOuter', 1), ('inner', 2), ('kInner', 2), ('segment', 3), ('kSegment', 3), ('closedSegment', 4), ('kClosedSegment', 4)], multiKeys=True)",
                                     'Form': "Enum('Form', [('invalid', 0), ('kInvalid', 0), ('open', 1), ('kOpen', 1), ('closed', 2), ('kClosed', 2), ('periodic', 3), ('kPeriodic', 3), ('last', 4), ('kLast', 4)], multiKeys=True)"},
                      'pymelMethods': {'knotInU': 'getKnotInU',
                                       'knotInV': 'getKnotInV'}},
  'MFnNurbsSurfaceData': {'enums': {},
                          'methods': {'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nClass name. \r\n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'create': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Nurbs Surface.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The new MObject ',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nFunction set type. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn',
                                                               'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {}},
  'MFnParticleSystem': {'enums': {'RenderType': {'valueDocs': {'blobby': '',
                                                               'cloud': '',
                                                               'kBlobby': '',
                                                               'kCloud': '',
                                                               'kMultiPoint': '',
                                                               'kMultiStreak': '',
                                                               'kNumeric': '',
                                                               'kPoints': '',
                                                               'kSpheres': '',
                                                               'kSprites': '',
                                                               'kStreak': '',
                                                               'kTube': '',
                                                               'multiPoint': '',
                                                               'multiStreak': '',
                                                               'numeric': '',
                                                               'points': '',
                                                               'spheres': '',
                                                               'sprites': '',
                                                               'streak': '',
                                                               'tube': ''},
                                                 'values': "Enum('RenderType', {'kCloud': 0, 'kTube': 1, 'kBlobby': 2, 'kMultiPoint': 3, 'kMultiStreak': 4, 'kNumeric': 5, 'kPoints': 6, 'kSpheres': 7, 'kSprites': 8, 'kStreak': 9})"}},
                        'invertibles': [('setCount', 'count'),
                                        ('setPerParticleAttribute',
                                         'getPerParticleAttribute')],
                        'methods': {'acceleration': [{'argInfo': {'array': {'doc': 'The resulting acceleration array ',
                                                                            'type': 'MVectorArray'}},
                                                      'args': [('array',
                                                                'MVectorArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nTo return acceleration array for all particles.',
                                                      'inArgs': [],
                                                      'outArgs': ['array'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'array': ['&']},
                                                      'types': {'array': 'MVectorArray'}}],
                                    'age': [{'argInfo': {'ages': {'doc': '',
                                                                  'type': 'MDoubleArray'}},
                                             'args': [('ages',
                                                       'MDoubleArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nPopulates the given array with the age values of the particles in this system. \r\n',
                                             'inArgs': ['ages'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'ages': ['&']},
                                             'types': {'ages': 'MDoubleArray'}}],
                                    'betterIllum': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kCloud.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'castsShadows': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns whether or not the rendering attribute for particles casting shadows has been enabled. \r\n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                    'count': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the particle count at the current frame. \r\n',
                                               'inArgs': [],
                                               'inverse': ('setCount',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nTo create a new particleShape with a transform.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The newly created particleShape',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}},
                                               {'argInfo': {'parentMObj': {'doc': 'The parent as an MObject ',
                                                                           'type': 'MObject'}},
                                                'args': [('parentMObj',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nTo create a new particleShape. If the parent is not specified, a new transform will be created as the parent.',
                                                'inArgs': ['parentMObj'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The newly created particleShape',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'parentMObj': []},
                                                'types': {'parentMObj': 'MObject'}}],
                                    'deformedParticleShape': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nTo get the deformed particleShape.',
                                                               'inArgs': [],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The particle shape connecting to the output of the deformer(s) ',
                                                                              'qualifiers': [],
                                                                              'type': 'MObject'},
                                                               'returnType': 'MObject',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                                               'types': {}}],
                                    'disableCloudAxis': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kCloud.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                    'emission': [{'argInfo': {'emissions': {'doc': '',
                                                                            'type': 'MVectorArray'}},
                                                  'args': [('emissions',
                                                            'MVectorArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nPopulates the given array with the incandescence values of the particles in this system, if the particles have this attribute. See  hasEmission() . \r\n',
                                                  'inArgs': ['emissions'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'emissions': ['&']},
                                                  'types': {'emissions': 'MVectorArray'}}],
                                    'emit': [{'argInfo': {'v': {'doc': "The particle's position",
                                                                'type': 'MPoint'}},
                                              'args': [('v',
                                                        'MPoint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nTo add a new particle at the given position.',
                                              'inArgs': ['v'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'v': ['const',
                                                                       '&']},
                                              'types': {'v': 'MPoint'}},
                                             {'argInfo': {'pArray': {'doc': "The particle's position array",
                                                                     'type': 'MPointArray'}},
                                              'args': [('pArray',
                                                        'MPointArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nTo add an array of new particles at the given positions.',
                                              'inArgs': ['pArray'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'pArray': ['const',
                                                                            '&']},
                                              'types': {'pArray': 'MPointArray'}},
                                             {'argInfo': {'p': {'doc': "The particle's position ",
                                                                'type': 'MPoint'},
                                                          'v': {'doc': "The particle's velocity",
                                                                'type': 'MVector'}},
                                              'args': [('p',
                                                        'MPoint',
                                                        'in'),
                                                       ('v',
                                                        'MVector',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nTo add a new particle at the position with its velocity.',
                                              'inArgs': ['p', 'v'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'p': ['const',
                                                                       '&'],
                                                                 'v': ['const',
                                                                       '&']},
                                              'types': {'p': 'MPoint',
                                                        'v': 'MVector'}},
                                             {'argInfo': {'pArray': {'doc': "The particle's position array ",
                                                                     'type': 'MPointArray'},
                                                          'vArray': {'doc': "The particle's velocity array",
                                                                     'type': 'MVectorArray'}},
                                              'args': [('pArray',
                                                        'MPointArray',
                                                        'in'),
                                                       ('vArray',
                                                        'MVectorArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nTo add an array of new particles at the given positions with their velocity values.',
                                              'inArgs': ['pArray',
                                                         'vArray'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'pArray': ['const',
                                                                            '&'],
                                                                 'vArray': ['const',
                                                                            '&']},
                                              'types': {'pArray': 'MPointArray',
                                                        'vArray': 'MVectorArray'}}],
                                    'evaluateDynamics': [{'argInfo': {'runupFromStart': {'doc': 'If true runup will begin at the start of the simulation, otherwise it will begin from the current frame. ',
                                                                                         'type': 'bool'},
                                                                      'to': {'doc': 'Time to run the particle system up to. ',
                                                                             'type': 'MTime'}},
                                                          'args': [('to',
                                                                    'MTime',
                                                                    'in'),
                                                                   ('runupFromStart',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nRun up the particle system to a certain frame, from either the current frame, or from the start of the simulation.',
                                                          'inArgs': ['to',
                                                                     'runupFromStart'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'runupFromStart': [],
                                                                             'to': ['&']},
                                                          'types': {'runupFromStart': 'bool',
                                                                    'to': 'MTime'}}],
                                    'flatShaded': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nTo check if a particle shape of cloud type is flat shaded. This is only for use with an  MFnParticleSystem  of renderType kCloud.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'getPerParticleAttribute': [{'argInfo': {'array': {'doc': 'The returned integer array ',
                                                                                       'type': 'MIntArray'},
                                                                             'attrName': {'doc': 'The input attribute name ',
                                                                                          'type': 'MString'}},
                                                                 'args': [('attrName',
                                                                           'MString',
                                                                           'in'),
                                                                          ('array',
                                                                           'MIntArray',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nTo get per particle integer attribute with its attribute name.',
                                                                 'inArgs': ['attrName'],
                                                                 'inverse': ('setPerParticleAttribute',
                                                                             False),
                                                                 'outArgs': ['array'],
                                                                 'returnInfo': {'doc': 'The size of the returned integer array',
                                                                                'qualifiers': [],
                                                                                'type': 'int'},
                                                                 'returnType': 'int',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'array': ['&'],
                                                                                    'attrName': ['const',
                                                                                                 '&']},
                                                                 'types': {'array': 'MIntArray',
                                                                           'attrName': 'MString'}},
                                                                {'argInfo': {'array': {'doc': 'The returned vector array ',
                                                                                       'type': 'MVectorArray'},
                                                                             'attrName': {'doc': 'The input attribute name ',
                                                                                          'type': 'MString'}},
                                                                 'args': [('attrName',
                                                                           'MString',
                                                                           'in'),
                                                                          ('array',
                                                                           'MVectorArray',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nTo get the per particle vector attribute of the given name.',
                                                                 'inArgs': ['attrName'],
                                                                 'inverse': ('setPerParticleAttribute',
                                                                             False),
                                                                 'outArgs': ['array'],
                                                                 'returnInfo': {'doc': 'The size of the returned vector array ',
                                                                                'qualifiers': [],
                                                                                'type': 'int'},
                                                                 'returnType': 'int',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'array': ['&'],
                                                                                    'attrName': ['const',
                                                                                                 '&']},
                                                                 'types': {'array': 'MVectorArray',
                                                                           'attrName': 'MString'}},
                                                                {'argInfo': {'array': {'doc': 'The returned double array ',
                                                                                       'type': 'MDoubleArray'},
                                                                             'attrName': {'doc': 'The input attribute name ',
                                                                                          'type': 'MString'}},
                                                                 'args': [('attrName',
                                                                           'MString',
                                                                           'in'),
                                                                          ('array',
                                                                           'MDoubleArray',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nTo get the per particle double attribute of the given name',
                                                                 'inArgs': ['attrName'],
                                                                 'inverse': ('setPerParticleAttribute',
                                                                             False),
                                                                 'outArgs': ['array'],
                                                                 'returnInfo': {'doc': 'The size of the returned double array',
                                                                                'qualifiers': [],
                                                                                'type': 'int'},
                                                                 'returnType': 'int',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'array': ['&'],
                                                                                    'attrName': ['const',
                                                                                                 '&']},
                                                                 'types': {'array': 'MDoubleArray',
                                                                           'attrName': 'MString'}}],
                                    'hasEmission': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns whether or not the particles in this system have an emission attribute. See  emission() . \r\n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'hasLifespan': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns whether or not the particles in this system have a lifespan attribute. See  lifespan() . \r\n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'hasOpacity': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns whether or not the particles in this system have an opacity attribute. See  opacity() . \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'hasRgb': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns whether or not the particles in this system have an rgb attribute. See  rgb() . \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                    'isDeformedParticleShape': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nTo return if this particle shape is deformed.',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'true  particle shape is deformed, false otherwise. ',
                                                                                'qualifiers': [],
                                                                                'type': 'bool'},
                                                                 'returnType': 'bool',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                                 'types': {}}],
                                    'isPerParticleDoubleAttribute': [{'argInfo': {'attrName': {'doc': 'The input attribute name ',
                                                                                               'type': 'MString'}},
                                                                      'args': [('attrName',
                                                                                'MString',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\r\nTo check if the input attribute is a per particle double attribute.',
                                                                      'inArgs': ['attrName'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': 'bool'},
                                                                      'returnType': 'bool',
                                                                      'static': False,
                                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                         'attrName': ['const',
                                                                                                      '&']},
                                                                      'types': {'attrName': 'MString'}}],
                                    'isPerParticleIntAttribute': [{'argInfo': {'attrName': {'doc': 'The input attribute name ',
                                                                                            'type': 'MString'}},
                                                                   'args': [('attrName',
                                                                             'MString',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nTo check if the input attribute is a per particle integer attribute.',
                                                                   'inArgs': ['attrName'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': 'bool'},
                                                                   'returnType': 'bool',
                                                                   'static': False,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'attrName': ['const',
                                                                                                   '&']},
                                                                   'types': {'attrName': 'MString'}}],
                                    'isPerParticleVectorAttribute': [{'argInfo': {'attrName': {'doc': 'The input attribute name ',
                                                                                               'type': 'MString'}},
                                                                      'args': [('attrName',
                                                                                'MString',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\r\nTo check if the input attribute is a per particle vector attribute.',
                                                                      'inArgs': ['attrName'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': 'bool'},
                                                                      'returnType': 'bool',
                                                                      'static': False,
                                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                         'attrName': ['const',
                                                                                                      '&']},
                                                                      'types': {'attrName': 'MString'}}],
                                    'isValid': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns false if the particle array is nullptr.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'lifespan': [{'argInfo': {'lifespans': {'doc': '',
                                                                            'type': 'MDoubleArray'}},
                                                  'args': [('lifespans',
                                                            'MDoubleArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nPopulates the given array with the lifespan values of the particles in this system, if the particles have this attribute. See  hasLifespan() . \r\n',
                                                  'inArgs': ['lifespans'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'lifespans': ['&']},
                                                  'types': {'lifespans': 'MDoubleArray'}}],
                                    'mass': [{'argInfo': {'array': {'doc': 'The resulting mass array ',
                                                                    'type': 'MDoubleArray'}},
                                              'args': [('array',
                                                        'MDoubleArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nTo return mass array for all particles.',
                                              'inArgs': [],
                                              'outArgs': ['array'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['&']},
                                              'types': {'array': 'MDoubleArray'}}],
                                    'opacity': [{'argInfo': {'opacities': {'doc': '',
                                                                           'type': 'MDoubleArray'}},
                                                 'args': [('opacities',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nPopulates the given array with the opacity values of the particles in this system, if the particles have this attribute. See  hasOpacity() . \r\n',
                                                 'inArgs': ['opacities'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'opacities': ['&']},
                                                 'types': {'opacities': 'MDoubleArray'}}],
                                    'originalParticleShape': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nTo get the original particleShape.',
                                                               'inArgs': [],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The particle shape connecting to the input of the deformer(s) ',
                                                                              'qualifiers': [],
                                                                              'type': 'MObject'},
                                                               'returnType': 'MObject',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                                               'types': {}}],
                                    'particleIds': [{'argInfo': {'ids': {'doc': 'Array of particle identifiers. The contents of the array are overwritten with the current list of particle identifiers. ',
                                                                         'type': 'MIntArray'}},
                                                     'args': [('ids',
                                                               'MIntArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nReturn an array of particle identifiers at the start of the time step. The array of particle id's is correlated with the other per-particle arrays returned by this class, so ids[i] will be the id for the particle with position position[i], velocity[i], etc., as long as all these arrays were retrieved for the same time step.",
                                                     'inArgs': [],
                                                     'outArgs': ['ids'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'ids': ['&']},
                                                     'types': {'ids': 'MIntArray'}}],
                                    'particleName': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the name of this particle system. \r\n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                    'position': [{'argInfo': {'positions': {'doc': '',
                                                                            'type': 'MVectorArray'}},
                                                  'args': [('positions',
                                                            'MVectorArray',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nCompute each particle's position at the start of the time step. This is done by taking the particle's current position and velocity, and extrapolation backwards in time.",
                                                  'inArgs': ['positions'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'positions': ['&']},
                                                  'types': {'positions': 'MVectorArray'}}],
                                    'position0': [{'argInfo': {'positions': {'doc': '',
                                                                             'type': 'MVectorArray'}},
                                                   'args': [('positions',
                                                             'MVectorArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kTube.',
                                                   'inArgs': ['positions'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'positions': ['&']},
                                                   'types': {'positions': 'MVectorArray'}}],
                                    'position1': [{'argInfo': {'positions': {'doc': '',
                                                                             'type': 'MVectorArray'}},
                                                   'args': [('positions',
                                                             'MVectorArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kTube.',
                                                   'inArgs': ['positions'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'positions': ['&']},
                                                   'types': {'positions': 'MVectorArray'}}],
                                    'primaryVisibility': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns whether or not the rendering attribute for primary visibility in reflections has been enabled. \r\n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                    'radius': [{'argInfo': {'radii': {'doc': '',
                                                                      'type': 'MDoubleArray'}},
                                                'args': [('radii',
                                                          'MDoubleArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCalculates particle radii.',
                                                'inArgs': ['radii'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'radii': ['&']},
                                                'types': {'radii': 'MDoubleArray'}}],
                                    'radius0': [{'argInfo': {'radii': {'doc': '',
                                                                       'type': 'MDoubleArray'}},
                                                 'args': [('radii',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kTube.',
                                                 'inArgs': ['radii'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'radii': ['&']},
                                                 'types': {'radii': 'MDoubleArray'}}],
                                    'radius1': [{'argInfo': {'radii': {'doc': '',
                                                                       'type': 'MDoubleArray'}},
                                                 'args': [('radii',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kTube.',
                                                 'inArgs': ['radii'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'radii': ['&']},
                                                 'types': {'radii': 'MDoubleArray'}}],
                                    'receiveShadows': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns whether or not the rendering attribute for particles receiving shadows has been enabled. \r\n',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'renderType': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the render type used by the particle object. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': ('MFnParticleSystem',
                                                                            'RenderType')},
                                                    'returnType': ('MFnParticleSystem',
                                                                   'RenderType'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'rgb': [{'argInfo': {'colors': {'doc': '',
                                                                    'type': 'MVectorArray'}},
                                             'args': [('colors',
                                                       'MVectorArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nPopulates the given array with the color values of the particles in this system, if the particles have this attribute. See  hasRgb() .',
                                             'inArgs': ['colors'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'colors': ['&']},
                                             'types': {'colors': 'MVectorArray'}}],
                                    'saveInitialState': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\r\nTo reset the particle's current state as the initial state.",
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                    'setCount': [{'argInfo': {'count': {'doc': 'Particle count. ',
                                                                        'type': 'uint'}},
                                                  'args': [('count',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the particle count at the current frame.',
                                                  'inArgs': ['count'],
                                                  'inverse': ('count',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'count': ['unsigned']},
                                                  'types': {'count': 'uint'}}],
                                    'setPerParticleAttribute': [{'argInfo': {'array': {'doc': 'The input vector array ',
                                                                                       'type': 'MVectorArray'},
                                                                             'attrName': {'doc': 'The input attribute name ',
                                                                                          'type': 'MString'}},
                                                                 'args': [('attrName',
                                                                           'MString',
                                                                           'in'),
                                                                          ('array',
                                                                           'MVectorArray',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nTo set the per particle vector attribute of the given name with the given values.',
                                                                 'inArgs': ['attrName',
                                                                            'array'],
                                                                 'inverse': ('getPerParticleAttribute',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'array': ['&'],
                                                                                    'attrName': ['const',
                                                                                                 '&']},
                                                                 'types': {'array': 'MVectorArray',
                                                                           'attrName': 'MString'}},
                                                                {'argInfo': {'array': {'doc': 'The input double array ',
                                                                                       'type': 'MDoubleArray'},
                                                                             'attrName': {'doc': 'The input attribute name ',
                                                                                          'type': 'MString'}},
                                                                 'args': [('attrName',
                                                                           'MString',
                                                                           'in'),
                                                                          ('array',
                                                                           'MDoubleArray',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nTo set the per particle double attribute of the given name with the given values.',
                                                                 'inArgs': ['attrName',
                                                                            'array'],
                                                                 'inverse': ('getPerParticleAttribute',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'array': ['&'],
                                                                                    'attrName': ['const',
                                                                                                 '&']},
                                                                 'types': {'array': 'MDoubleArray',
                                                                           'attrName': 'MString'}}],
                                    'surfaceShading': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kCloud.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'double'},
                                                        'returnType': 'double',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'tailSize': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kTube.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'threshold': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nOnly for use with an  MFnParticleSystem  of renderType kCloud or kBlobby.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'double'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFunction set type. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'velocity': [{'argInfo': {'array': {'doc': 'The resulting velocity array ',
                                                                        'type': 'MVectorArray'}},
                                                  'args': [('array',
                                                            'MVectorArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nTo return velocity array for all particles.',
                                                  'inArgs': [],
                                                  'outArgs': ['array'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'array': ['&']},
                                                  'types': {'array': 'MVectorArray'}}],
                                    'visibleInReflections': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns whether or not the rendering attribute for particle visibility in reflections has been enabled. \r\n',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                    'visibleInRefractions': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns whether or not the rendering attribute for particle visibility in refractions has been enabled. \r\n',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}]},
                        'pymelEnums': {'RenderType': "Enum('RenderType', [('cloud', 0), ('kCloud', 0), ('tube', 1), ('kTube', 1), ('blobby', 2), ('kBlobby', 2), ('multiPoint', 3), ('kMultiPoint', 3), ('multiStreak', 4), ('kMultiStreak', 4), ('numeric', 5), ('kNumeric', 5), ('points', 6), ('kPoints', 6), ('spheres', 7), ('kSpheres', 7), ('sprites', 8), ('kSprites', 8), ('streak', 9), ('kStreak', 9)], multiKeys=True)"},
                        'pymelMethods': {'count': 'getCount'}},
  'MFnPartition': {'enums': {},
                   'methods': {'addMember': [{'argInfo': {'set': {'doc': 'new set to be added to this partiton.',
                                                                  'type': 'MObject'}},
                                              'args': [('set',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nAdd a set to this partition. To be added to a partition, a set must be mutually exclusive with all of the other sets in the partition. If there are any conflicting elements, then the add will fail.',
                                              'inArgs': ['set'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'set': ['const',
                                                                         '&']},
                                              'types': {'set': 'MObject'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nClass name. \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'create': [{'argInfo': {'isRenderPartition': {'doc': 'determines whether this partition is a render partition ',
                                                                             'type': 'bool'}},
                                           'args': [('isRenderPartition',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'isRenderPartition': False},
                                           'deprecated': False,
                                           'doc': '\nCreates a new partition dependency node and puts it in the dependency graph.',
                                           'inArgs': ['isRenderPartition'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A handle for the new partition object',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'isRenderPartition': []},
                                           'types': {'isRenderPartition': 'bool'}}],
                               'isRenderPartition': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturns true if this partition is a render partition.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A boolean value indicating whether the object is a member',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                               'removeMember': [{'argInfo': {'set': {'doc': 'old set to be removed from this partiton.',
                                                                     'type': 'MObject'}},
                                                 'args': [('set',
                                                           'MObject',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nRemove a set from this partition.',
                                                 'inArgs': ['set'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'set': ['const',
                                                                            '&']},
                                                 'types': {'set': 'MObject'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nFunction set type. \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {}},
  'MFnPfxGeometry': {'enums': {},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClass name. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'getBoundingBox': [{'argInfo': {'max': {'doc': 'maximum coordinates',
                                                                         'type': 'double'},
                                                                 'min': {'doc': 'minimum coordinates ',
                                                                         'type': 'double'}},
                                                     'args': [('min',
                                                               'double',
                                                               'out'),
                                                              ('max',
                                                               'double',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGets the bounding box of the specified geometry. The passed in double arrays will be filled with minimum and maximum coordinates of the geometry.',
                                                     'inArgs': [],
                                                     'outArgs': ['min',
                                                                 'max'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'max': ['*'],
                                                                        'min': ['*']},
                                                     'types': {'max': 'double',
                                                               'min': 'double'}}],
                                 'getLineData': [{'argInfo': {'doColor': {'doc': 'create color arrays ',
                                                                          'type': 'bool'},
                                                              'doFlatness': {'doc': 'create flatness arrays ',
                                                                             'type': 'bool'},
                                                              'doIncandescence': {'doc': 'create incandescence arrays ',
                                                                                  'type': 'bool'},
                                                              'doLines': {'doc': 'create line(vertex) arrays ',
                                                                          'type': 'bool'},
                                                              'doParameter': {'doc': 'create parameter arrays ',
                                                                              'type': 'bool'},
                                                              'doTransparency': {'doc': 'create transparency arrays ',
                                                                                 'type': 'bool'},
                                                              'doTwist': {'doc': 'create twist arrays ',
                                                                          'type': 'bool'},
                                                              'doWidth': {'doc': 'create width arrays ',
                                                                          'type': 'bool'},
                                                              'flowerLines': {'doc': 'flower MRenderLineArray',
                                                                              'type': 'MRenderLineArray'},
                                                              'leafLines': {'doc': 'leaf MRenderLineArray ',
                                                                            'type': 'MRenderLineArray'},
                                                              'mainLines': {'doc': 'primary MRenderLineArray ',
                                                                            'type': 'MRenderLineArray'},
                                                              'worldSpace': {'doc': 'compute lines in worldspace, instead of the stroke objectspace',
                                                                             'type': 'bool'}},
                                                  'args': [('mainLines',
                                                            'MRenderLineArray',
                                                            'out'),
                                                           ('leafLines',
                                                            'MRenderLineArray',
                                                            'out'),
                                                           ('flowerLines',
                                                            'MRenderLineArray',
                                                            'out'),
                                                           ('doLines',
                                                            'bool',
                                                            'in'),
                                                           ('doTwist',
                                                            'bool',
                                                            'in'),
                                                           ('doWidth',
                                                            'bool',
                                                            'in'),
                                                           ('doFlatness',
                                                            'bool',
                                                            'in'),
                                                           ('doParameter',
                                                            'bool',
                                                            'in'),
                                                           ('doColor',
                                                            'bool',
                                                            'in'),
                                                           ('doIncandescence',
                                                            'bool',
                                                            'in'),
                                                           ('doTransparency',
                                                            'bool',
                                                            'in'),
                                                           ('worldSpace',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet line data for the current output pfx tubes. The passed in arrays will be filled with pointers to MrenderLine classes. If there are no leaves or flowers then the passed in leafLine and flowerLine arrays will be left empty. Arrays are generated for only the specified attributes. This routine creates the memory for the arrays that it computes. This memory can only be released using the deleteArray method on the  MRenderLineArray  class. DeleteArray should be called for the mainLine, leafLine, and flowerLine variables when done. These variables wrap the returned data and allow access but the  MRenderLineArray  destructer does not delete this wrapped memory, so one must use  MRenderLineArray::deleteArray() . The  MRenderLine ,  MVectorArray  and MDoubleArrays returned from  MRenderLineArray  will point to deleted memory after calling deleteArray, so be careful to only call deleteArray when finished using the line data(or copy the arrays first).',
                                                  'inArgs': ['doLines',
                                                             'doTwist',
                                                             'doWidth',
                                                             'doFlatness',
                                                             'doParameter',
                                                             'doColor',
                                                             'doIncandescence',
                                                             'doTransparency',
                                                             'worldSpace'],
                                                  'outArgs': ['mainLines',
                                                              'leafLines',
                                                              'flowerLines'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'doColor': [],
                                                                     'doFlatness': [],
                                                                     'doIncandescence': [],
                                                                     'doLines': [],
                                                                     'doParameter': [],
                                                                     'doTransparency': [],
                                                                     'doTwist': [],
                                                                     'doWidth': [],
                                                                     'flowerLines': ['&'],
                                                                     'leafLines': ['&'],
                                                                     'mainLines': ['&'],
                                                                     'worldSpace': []},
                                                  'types': {'doColor': 'bool',
                                                            'doFlatness': 'bool',
                                                            'doIncandescence': 'bool',
                                                            'doLines': 'bool',
                                                            'doParameter': 'bool',
                                                            'doTransparency': 'bool',
                                                            'doTwist': 'bool',
                                                            'doWidth': 'bool',
                                                            'flowerLines': 'MRenderLineArray',
                                                            'leafLines': 'MRenderLineArray',
                                                            'mainLines': 'MRenderLineArray',
                                                            'worldSpace': 'bool'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnPhongEShader': {'enums': {},
                      'invertibles': [('setWhiteness', 'whiteness'),
                                      ('setHighlightSize', 'highlightSize'),
                                      ('setRoughness', 'roughness')],
                      'methods': {'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nClass name. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not the new node will be connected to the shader classification node. ',
                                                                        'type': 'bool'}},
                                              'args': [('UIvisible',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'UIvisible': True},
                                              'deprecated': False,
                                              'doc': '\nCreates a new layered shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.',
                                              'inArgs': ['UIvisible'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'UIvisible': []},
                                              'types': {'UIvisible': 'bool'}}],
                                  'highlightSize': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the value of the "highlightSize" attribute of a shader node. This attribute represents the surface color of the shader.',
                                                     'inArgs': [],
                                                     'inverse': ('setHighlightSize',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "highlightSize" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                  'roughness': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nRetrieves the value of the "roughness" attribute of a shader node.',
                                                 'inArgs': [],
                                                 'inverse': ('setRoughness',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The value of the "roughness" attribute of the shader node.',
                                                                'qualifiers': [],
                                                                'type': 'float'},
                                                 'returnType': 'float',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                  'setHighlightSize': [{'argInfo': {'highlight_size': {'doc': 'value to which the attribute will be set.',
                                                                                       'type': 'float'}},
                                                        'args': [('highlight_size',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the value of the "highlightSize" attribute of a shader node.',
                                                        'inArgs': ['highlight_size'],
                                                        'inverse': ('highlightSize',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'highlight_size': ['const',
                                                                                              '&']},
                                                        'types': {'highlight_size': 'float'}}],
                                  'setRoughness': [{'argInfo': {'roughness': {'doc': 'value to which the attribute will be set.',
                                                                              'type': 'float'}},
                                                    'args': [('roughness',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets the value of the "roughness" attribute of a shader node.',
                                                    'inArgs': ['roughness'],
                                                    'inverse': ('roughness',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'roughness': ['const',
                                                                                     '&']},
                                                    'types': {'roughness': 'float'}}],
                                  'setWhiteness': [{'argInfo': {'whiteness': {'doc': 'value to which the attribute will be set.',
                                                                              'type': 'MColor'}},
                                                    'args': [('whiteness',
                                                              'MColor',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets the value of the "whiteness" attribute of a shader node.',
                                                    'inArgs': ['whiteness'],
                                                    'inverse': ('whiteness',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'whiteness': ['const',
                                                                                     '&']},
                                                    'types': {'whiteness': 'MColor'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFunction set type. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                  'whiteness': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nRetrieves the value of the "whiteness" attribute of a shader node. This attribute represents the surface transparency of the shader.',
                                                 'inArgs': [],
                                                 'inverse': ('setWhiteness',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The value of the "whiteness" attribute of the shader node.',
                                                                'qualifiers': [],
                                                                'type': 'MColor'},
                                                 'returnType': 'MColor',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'highlightSize': 'getHighlightSize',
                                       'roughness': 'getRoughness',
                                       'whiteness': 'getWhiteness'}},
  'MFnPhongShader': {'enums': {},
                     'invertibles': [('setCosPower', 'cosPower')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nClass name. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'cosPower': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nRetrieves the value of the "cosPower" attribute of a phong shader node. This attribute determines the size of specular highlights produced by the shader.',
                                               'inArgs': [],
                                               'inverse': ('setCosPower',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the "cosPower" attribute of the shader node.',
                                                              'qualifiers': [],
                                                              'type': 'float'},
                                               'returnType': 'float',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not the new node will be connected to the shader classification node. ',
                                                                       'type': 'bool'}},
                                             'args': [('UIvisible',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'UIvisible': True},
                                             'deprecated': False,
                                             'doc': '\nCreates a new phong shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.',
                                             'inArgs': ['UIvisible'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'UIvisible': []},
                                             'types': {'UIvisible': 'bool'}}],
                                 'setCosPower': [{'argInfo': {'cos_power': {'doc': 'value to which the attribute will be set.',
                                                                            'type': 'float'}},
                                                  'args': [('cos_power',
                                                            'float',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nSets the value of the "cosPower" attribute of a shader node.',
                                                  'inArgs': ['cos_power'],
                                                  'inverse': ('cosPower',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'cos_power': ['const',
                                                                                   '&']},
                                                  'types': {'cos_power': 'float'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'cosPower': 'getCosPower'}},
  'MFnPlugin': {'enums': {},
                'invertibles': [('setName', 'name'),
                                ('setVersion', 'version')],
                'methods': {'addMenuItem': [{'argInfo': {'commandName': {'doc': 'Command to be attached. ',
                                                                         'type': 'MString'},
                                                         'commandParams': {'doc': 'Parameters for the command. ',
                                                                           'type': 'MString'},
                                                         'extraMenuItemParams': {'doc': 'Parameters for creating the menuItem.',
                                                                                 'type': 'MString'},
                                                         'menuItemName': {'doc': 'This will be used as the label for the menuItem. ',
                                                                          'type': 'MString'},
                                                         'needOptionBox': {'doc': 'Boolean indicating whether an option box is required. Default value is false. ',
                                                                           'type': 'bool'},
                                                         'optBoxFunction': {'doc': 'MEL Function to be attached to the option box. If the needOptionBox is false, then this argument will have no effect. ',
                                                                            'type': 'MString'},
                                                         'parentName': {'doc': 'Name of the parent to which the new menuItem needs to be attached. ',
                                                                        'type': 'MString'}},
                                             'args': [('menuItemName',
                                                       'MString',
                                                       'in'),
                                                      ('parentName',
                                                       'MString',
                                                       'in'),
                                                      ('commandName',
                                                       'MString',
                                                       'in'),
                                                      ('commandParams',
                                                       'MString',
                                                       'in'),
                                                      ('needOptionBox',
                                                       'bool',
                                                       'in'),
                                                      ('optBoxFunction',
                                                       'MString',
                                                       'in'),
                                                      ('extraMenuItemParams',
                                                       'MString',
                                                       'in')],
                                             'defaults': {'extraMenuItemParams': None,
                                                          'needOptionBox': False,
                                                          'optBoxFunction': None},
                                             'deprecated': False,
                                             'doc': '\r\nThe function adds the menuItem to the specified parent, and associates a command with it. Additionally, an option box can be created and a MEL function/command can be added to it. The function returns the names of the new menuItem and the optionBox created.',
                                             'inArgs': ['menuItemName',
                                                        'parentName',
                                                        'commandName',
                                                        'commandParams',
                                                        'needOptionBox',
                                                        'optBoxFunction',
                                                        'extraMenuItemParams'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MStringArray returns the names of the new menuItems created. In case the method fails, and MStringArray has items in it, removeMenuItem() should be called on it to remove the unused UI references. ',
                                                            'qualifiers': [],
                                                            'type': 'MStringArray'},
                                             'returnType': 'MStringArray',
                                             'static': False,
                                             'typeQualifiers': {'commandName': ['const',
                                                                                '&'],
                                                                'commandParams': ['const',
                                                                                  '&'],
                                                                'extraMenuItemParams': ['const',
                                                                                        '*'],
                                                                'menuItemName': ['const',
                                                                                 '&'],
                                                                'needOptionBox': [],
                                                                'optBoxFunction': ['const',
                                                                                   '*'],
                                                                'parentName': ['const',
                                                                               '&'],
                                                                'retStatus': ['*']},
                                             'types': {'commandName': 'MString',
                                                       'commandParams': 'MString',
                                                       'extraMenuItemParams': 'MString',
                                                       'menuItemName': 'MString',
                                                       'needOptionBox': 'bool',
                                                       'optBoxFunction': 'MString',
                                                       'parentName': 'MString'}}],
                            'apiVersion': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the required API version string supplied in the  MFnPlugin  constructor.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'An MString containing the required API version string ',
                                                           'qualifiers': [],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'deregisterAnimCurveInterpolator': [{'argInfo': {'typeName': {'doc': 'the unique type id of the interpolator to deregister',
                                                                                          'type': 'MString'}},
                                                                 'args': [('typeName',
                                                                           'MString',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nDeregister the given user defined animation curve interpolator from Maya.',
                                                                 'inArgs': ['typeName'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'typeName': ['const',
                                                                                                 '&']},
                                                                 'types': {'typeName': 'MString'}}],
                            'deregisterAttributePatternFactory': [{'argInfo': {'attributePatternFactoryName': {'doc': 'the attribute pattern factory name.',
                                                                                                               'type': 'MString'}},
                                                                   'args': [('attributePatternFactoryName',
                                                                             'MString',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nDeregister the attribute pattern factory type with Maya.',
                                                                   'inArgs': ['attributePatternFactoryName'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'attributePatternFactoryName': ['const',
                                                                                                                      '&']},
                                                                   'types': {'attributePatternFactoryName': 'MString'}}],
                            'deregisterCacheFormat': [{'argInfo': {'cacheFormatName': {'doc': 'the name of the cache format to deregister',
                                                                                       'type': 'MString'}},
                                                       'args': [('cacheFormatName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nDeregister the specified cache format with Maya.',
                                                       'inArgs': ['cacheFormatName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'cacheFormatName': ['const',
                                                                                              '&']},
                                                       'types': {'cacheFormatName': 'MString'}}],
                            'deregisterCommand': [{'argInfo': {'commandName': {'doc': 'the name of the command to deregister',
                                                                               'type': 'MString'}},
                                                   'args': [('commandName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDeregister the user defined command from Maya. Once deregistered the command can no longer be invoked from MEL.',
                                                   'inArgs': ['commandName'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'commandName': ['const',
                                                                                      '&']},
                                                   'types': {'commandName': 'MString'}}],
                            'deregisterConstraintCommand': [{'argInfo': {'commandName': {'doc': 'the name of the command to deregister',
                                                                                         'type': 'MString'}},
                                                             'args': [('commandName',
                                                                       'MString',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nDeregister the user defined constraint command from Maya. Once deregistered the command can no longer be invoked from MEL.',
                                                             'inArgs': ['commandName'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'commandName': ['const',
                                                                                                '&']},
                                                             'types': {'commandName': 'MString'}}],
                            'deregisterContextCommand': [{'argInfo': {'commandName': {'doc': 'the name of the context command to deregister',
                                                                                      'type': 'MString'}},
                                                          'args': [('commandName',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDeregister the given user defined context command from Maya. Once deregistered the user defined tool can no longer be used.',
                                                          'inArgs': ['commandName'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'commandName': ['const',
                                                                                             '&']},
                                                          'types': {'commandName': 'MString'}},
                                                         {'argInfo': {'commandName': {'doc': 'the name of the context command to deregister ',
                                                                                      'type': 'MString'},
                                                                      'toolCmdName': {'doc': 'the name of the command to deregister',
                                                                                      'type': 'MString'}},
                                                          'args': [('commandName',
                                                                    'MString',
                                                                    'in'),
                                                                   ('toolCmdName',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDeregister the given user defined context command and tool command from Maya. Once deregistered the user defined tool can no longer be used and the tool command can no longer be invoked from MEL.',
                                                          'inArgs': ['commandName',
                                                                     'toolCmdName'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'commandName': ['const',
                                                                                             '&'],
                                                                             'toolCmdName': ['const',
                                                                                             '&']},
                                                          'types': {'commandName': 'MString',
                                                                    'toolCmdName': 'MString'}}],
                            'deregisterControlCommand': [{'argInfo': {'commandName': {'doc': 'the name of the command to deregister',
                                                                                      'type': 'MString'}},
                                                          'args': [('commandName',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDeregister the user defined control command from Maya. Once deregistered the command can no longer be invoked from MEL.',
                                                          'inArgs': ['commandName'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'commandName': ['const',
                                                                                             '&']},
                                                          'types': {'commandName': 'MString'}}],
                            'deregisterData': [{'argInfo': {'typeId': {'doc': 'the unique type id of the data type to deregister',
                                                                       'type': 'MTypeId'}},
                                                'args': [('typeId',
                                                          'MTypeId',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDeregister the given user defined data type from Maya.',
                                                'inArgs': ['typeId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'typeId': ['const',
                                                                              '&']},
                                                'types': {'typeId': 'MTypeId'}}],
                            'deregisterDevice': [{'argInfo': {'deviceName': {'doc': 'the name of the input device to deregister',
                                                                             'type': 'MString'}},
                                                  'args': [('deviceName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nDeregister the given user defined input device from Maya.',
                                                  'inArgs': ['deviceName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'deviceName': ['const',
                                                                                    '&']},
                                                  'types': {'deviceName': 'MString'}}],
                            'deregisterDisplayFilter': [{'argInfo': {'name': {'doc': 'the display filter name',
                                                                              'type': 'MString'}},
                                                         'args': [('name',
                                                                   'MString',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nDeregister a display filter with Maya.',
                                                         'inArgs': ['name'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'name': ['const',
                                                                                     '&']},
                                                         'types': {'name': 'MString'}}],
                            'deregisterDragAndDropBehavior': [{'argInfo': {'behaviorName': {'doc': 'the name of the behavior to deregister',
                                                                                            'type': 'MString'}},
                                                               'args': [('behaviorName',
                                                                         'MString',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nDeregister the given drag and drop behavior from Maya.',
                                                               'inArgs': ['behaviorName'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'behaviorName': ['const',
                                                                                                   '&']},
                                                               'types': {'behaviorName': 'MString'}}],
                            'deregisterEvaluator': [{'argInfo': {'evaluatorName': {'doc': 'the name of the evaluator.',
                                                                                   'type': 'MString'}},
                                                     'args': [('evaluatorName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nDeregister the given user defined evaluator. Once deregistered, the evaluator can no longer be used until registered again.',
                                                     'inArgs': ['evaluatorName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'evaluatorName': ['const',
                                                                                          '&']},
                                                     'types': {'evaluatorName': 'MString'}}],
                            'deregisterFileTranslator': [{'argInfo': {'translatorName': {'doc': 'the name of the translator to deregister',
                                                                                         'type': 'MString'}},
                                                          'args': [('translatorName',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDeregister the specified file translator with Maya.',
                                                          'inArgs': ['translatorName'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'translatorName': ['const',
                                                                                                '&']},
                                                          'types': {'translatorName': 'MString'}}],
                            'deregisterIkSolver': [{'argInfo': {'ikSolverName': {'doc': 'the name of the ik solver to deregister',
                                                                                 'type': 'MString'}},
                                                    'args': [('ikSolverName',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDeregister the specified ik-solver with Maya. NOTE: this method is obsolete. Instead, register the IK solver as a node as described in the example plug-in simpleSolverNode.cpp.',
                                                    'inArgs': ['ikSolverName'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'ikSolverName': ['const',
                                                                                        '&']},
                                                    'types': {'ikSolverName': 'MString'}}],
                            'deregisterImageFile': [{'argInfo': {'imageFormatName': {'doc': 'the name of the image format to deregister',
                                                                                     'type': 'MString'}},
                                                     'args': [('imageFormatName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nDeregister the specified image file translator with Maya.',
                                                     'inArgs': ['imageFormatName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'imageFormatName': ['const',
                                                                                            '&']},
                                                     'types': {'imageFormatName': 'MString'}}],
                            'deregisterModelEditorCommand': [{'argInfo': {'commandName': {'doc': 'the name of the command to deregister',
                                                                                          'type': 'MString'}},
                                                              'args': [('commandName',
                                                                        'MString',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nDeregister the user defined editor command from Maya. Once deregistered the command can no longer be invoked from MEL.',
                                                              'inArgs': ['commandName'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'commandName': ['const',
                                                                                                 '&']},
                                                              'types': {'commandName': 'MString'}}],
                            'deregisterNode': [{'argInfo': {'typeId': {'doc': 'the unique type id of the node type to deregister',
                                                                       'type': 'MTypeId'}},
                                                'args': [('typeId',
                                                          'MTypeId',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDeregister the given user defined dependency node type Maya. Once deregistered new instances of the user defined dependency node can no longer be created. Additionally, any existing instances of the node type will be changed to the special type  Unknown  and will no longer evaluate in the dependency graph although they will be saved correctly if the scene is written.',
                                                'inArgs': ['typeId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'typeId': ['const',
                                                                              '&']},
                                                'types': {'typeId': 'MTypeId'}}],
                            'deregisterRenderPassImpl': [{'argInfo': {'passImplId': {'doc': 'the name identifying the pass implementation to remove',
                                                                                     'type': 'MString'}},
                                                          'args': [('passImplId',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDeregister the specified render pass implementation with Maya. This will remove the implementation from all passes it is associated with.',
                                                          'inArgs': ['passImplId'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'passImplId': ['const',
                                                                                            '&']},
                                                          'types': {'passImplId': 'MString'}}],
                            'deregisterRenderer': [{'argInfo': {'name': {'doc': 'The name of the renderer',
                                                                         'type': 'MString'}},
                                                    'args': [('name',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDeregisters an renderer identified by name.',
                                                    'inArgs': ['name'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'name': ['const',
                                                                                '&']},
                                                    'types': {'name': 'MString'}}],
                            'deregisterURIFileResolver': [{'argInfo': {'fileResolverName': {'doc': 'the name of the file resolver to deregister',
                                                                                            'type': 'MString'}},
                                                           'args': [('fileResolverName',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nDeregister the specified URI file resolver with Maya.',
                                                           'inArgs': ['fileResolverName'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'fileResolverName': ['const',
                                                                                                   '&']},
                                                           'types': {'fileResolverName': 'MString'}}],
                            'findPlugin': [{'argInfo': {'pluginName': {'doc': 'the name of the plugin you want a handle for.',
                                                                       'type': 'MString'}},
                                            'args': [('pluginName',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\r\nReturns an  MObject  corresponding to the named plugin. If the plugin isn't loaded, the  MObject  will be kNullObj. This  MObject  may be used in the same way as the  MObject  passed to the plugin's initializePlugin() function. Do not hold onto this  MObject , if you need it again later, call  findPlugin()  again.",
                                            'inArgs': ['pluginName'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': " An MObject corresponding to the plugin if the plugin is loaded.  MObject::kNullObj if the plugin isn't loaded.   ",
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': True,
                                            'typeQualifiers': {'pluginName': ['const',
                                                                              '&']},
                                            'types': {'pluginName': 'MString'}}],
                            'isNodeRegistered': [{'argInfo': {'typeName': {'doc': 'the type name of a depend graph node to query.',
                                                                           'type': 'MString'}},
                                                  'args': [('typeName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nQueries if the given typeName has been registered by maya or plugins.',
                                                  'inArgs': ['typeName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if registered, false otherwise. ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': True,
                                                  'typeQualifiers': {'typeName': ['const',
                                                                                  '&']},
                                                  'types': {'typeName': 'MString'}}],
                            'loadPath': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermine the path where the plugin was loaded.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'An MString containing path name to the location of the plugin. ',
                                                         'qualifiers': [],
                                                         'type': 'MString'},
                                          'returnType': 'MString',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                            'matrixTypeIdFromXformId': [{'argInfo': {'xformTypeId': {'doc': 'the typeId of the transform. ',
                                                                                     'type': 'MTypeId'}},
                                                         'args': [('xformTypeId',
                                                                   'MTypeId',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nThe function returns the  MTypeId  of the matrix when the  MTypeId  of the corresponding xform is given.',
                                                         'inArgs': ['xformTypeId'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'MTypeId TypeId of the corresponding transformation matrix, if found. ',
                                                                        'qualifiers': [],
                                                                        'type': 'MTypeId'},
                                                         'returnType': 'MTypeId',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'xformTypeId': ['const',
                                                                                            '&']},
                                                         'types': {'xformTypeId': 'MTypeId'}}],
                            'name': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn the name by which Maya knows this plug-in.',
                                      'inArgs': [],
                                      'inverse': ('setName', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'An MString containing the plug-in name ',
                                                     'qualifiers': [],
                                                     'type': 'MString'},
                                      'returnType': 'MString',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                            'registerAnimCurveInterpolator': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxAnimCurveInterpolator) that implements the new interpolator. ',
                                                                                               'type': ('MFnPlugin',
                                                                                                        'MCreatorFunction')},
                                                                           'flags': {'doc': 'an integer value containing a combination of enum values as specified in the InterpolatorFlags enumerated type (see MPxAnimCurveInterpolator). The default value is 0.',
                                                                                     'type': 'int'},
                                                                           'typeId': {'doc': 'the unique type id of the interpolator to register. See MPxAnimCurveInterpolator. ',
                                                                                      'type': 'int'},
                                                                           'typeName': {'doc': 'the name of the interpolator to register ',
                                                                                        'type': 'MString'}},
                                                               'args': [('typeName',
                                                                         'MString',
                                                                         'in'),
                                                                        ('typeId',
                                                                         'int',
                                                                         'in'),
                                                                        ('creatorFunction',
                                                                         ('MFnPlugin',
                                                                          'MCreatorFunction'),
                                                                         'in'),
                                                                        ('flags',
                                                                         'int',
                                                                         'in')],
                                                               'defaults': {'flags': 0},
                                                               'deprecated': False,
                                                               'doc': '\r\nRegister a new animation curve interpolator with Maya. Once registered, the interpolator can be used in interpolating between keyframes.',
                                                               'inArgs': ['typeName',
                                                                          'typeId',
                                                                          'creatorFunction',
                                                                          'flags'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'creatorFunction': [],
                                                                                  'flags': [],
                                                                                  'typeId': [],
                                                                                  'typeName': ['const',
                                                                                               '&']},
                                                               'types': {'creatorFunction': ('MFnPlugin',
                                                                                             'MCreatorFunction'),
                                                                         'flags': 'int',
                                                                         'typeId': 'int',
                                                                         'typeName': 'MString'}}],
                            'registerAttributePatternFactory': [{'argInfo': {'creatorFunction': {'doc': 'pointer to function that returns a new instance of an attribute pattern factory.',
                                                                                                 'type': ('MFnPlugin',
                                                                                                          'MCreatorFunction')},
                                                                             'patternFactoryName': {'doc': 'the new attribute pattern factory name. ',
                                                                                                    'type': 'MString'}},
                                                                 'args': [('patternFactoryName',
                                                                           'MString',
                                                                           'in'),
                                                                          ('creatorFunction',
                                                                           ('MFnPlugin',
                                                                            'MCreatorFunction'),
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nRegisters a new attribute pattern factory type with Maya.',
                                                                 'inArgs': ['patternFactoryName',
                                                                            'creatorFunction'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'creatorFunction': [],
                                                                                    'patternFactoryName': ['const',
                                                                                                           '&']},
                                                                 'types': {'creatorFunction': ('MFnPlugin',
                                                                                               'MCreatorFunction'),
                                                                           'patternFactoryName': 'MString'}}],
                            'registerBakeEngine': [{'argInfo': {'bakeEngineGenName': {'doc': 'the new bake engine generator name. ',
                                                                                      'type': 'MString'},
                                                                'fnPtr': {'doc': 'pointer to function that return a new instance of bake engine generator node.',
                                                                          'type': 'MBakeEngineCreatorFnPtr'}},
                                                    'args': [('bakeEngineGenName',
                                                              'MString',
                                                              'in'),
                                                             ('fnPtr',
                                                              'MBakeEngineCreatorFnPtr',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRegisters a new bake engine type with Maya.',
                                                    'inArgs': ['bakeEngineGenName',
                                                               'fnPtr'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'bakeEngineGenName': ['const',
                                                                                             '&'],
                                                                       'fnPtr': []},
                                                    'types': {'bakeEngineGenName': 'MString',
                                                              'fnPtr': 'MBakeEngineCreatorFnPtr'}}],
                            'registerCacheFormat': [{'argInfo': {'cacheFormatName': {'doc': 'Name of the new cache format. ',
                                                                                     'type': 'MString'},
                                                                 'creatorFunction': {'doc': 'Pointer to a function that will return a pointer to a new instance of the class (derived from MPxCacheFormat) that implements the new file type.',
                                                                                     'type': ('MFnPlugin',
                                                                                              'MCreatorFunction')}},
                                                     'args': [('cacheFormatName',
                                                               'MString',
                                                               'in'),
                                                              ('creatorFunction',
                                                               ('MFnPlugin',
                                                                'MCreatorFunction'),
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nRegister a new cache format with Maya.',
                                                     'inArgs': ['cacheFormatName',
                                                                'creatorFunction'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'cacheFormatName': ['const',
                                                                                            '&'],
                                                                        'creatorFunction': []},
                                                     'types': {'cacheFormatName': 'MString',
                                                               'creatorFunction': ('MFnPlugin',
                                                                                   'MCreatorFunction')}}],
                            'registerCommand': [{'argInfo': {'commandName': {'doc': 'the name of the command to register ',
                                                                             'type': 'MString'},
                                                             'createSyntaxFunction': {'doc': 'a pointer to a function that will return a new instance of a syntax object (MSyntax) that implements the syntax of the command.',
                                                                                      'type': ('MFnPlugin',
                                                                                               'MCreateSyntaxFunction')},
                                                             'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxCommand) that implements the new command. ',
                                                                                 'type': ('MFnPlugin',
                                                                                          'MCreatorFunction')}},
                                                 'args': [('commandName',
                                                           'MString',
                                                           'in'),
                                                          ('creatorFunction',
                                                           ('MFnPlugin',
                                                            'MCreatorFunction'),
                                                           'in'),
                                                          ('createSyntaxFunction',
                                                           ('MFnPlugin',
                                                            'MCreateSyntaxFunction'),
                                                           'in')],
                                                 'defaults': {'createSyntaxFunction': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nRegister a new command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.',
                                                 'inArgs': ['commandName',
                                                            'creatorFunction',
                                                            'createSyntaxFunction'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'commandName': ['const',
                                                                                    '&'],
                                                                    'createSyntaxFunction': [],
                                                                    'creatorFunction': []},
                                                 'types': {'commandName': 'MString',
                                                           'createSyntaxFunction': ('MFnPlugin',
                                                                                    'MCreateSyntaxFunction'),
                                                           'creatorFunction': ('MFnPlugin',
                                                                               'MCreatorFunction')}}],
                            'registerConstraintCommand': [{'argInfo': {'commandName': {'doc': 'the name of the command to register ',
                                                                                       'type': 'MString'},
                                                                       'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxConstraintCommand) that implements the new command.',
                                                                                           'type': ('MFnPlugin',
                                                                                                    'MCreatorFunction')}},
                                                           'args': [('commandName',
                                                                     'MString',
                                                                     'in'),
                                                                    ('creatorFunction',
                                                                     ('MFnPlugin',
                                                                      'MCreatorFunction'),
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nRegister a new constraint command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.',
                                                           'inArgs': ['commandName',
                                                                      'creatorFunction'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'commandName': ['const',
                                                                                              '&'],
                                                                              'creatorFunction': []},
                                                           'types': {'commandName': 'MString',
                                                                     'creatorFunction': ('MFnPlugin',
                                                                                         'MCreatorFunction')}}],
                            'registerContextCommand': [{'argInfo': {'commandName': {'doc': 'the name of the context command to register ',
                                                                                    'type': 'MString'},
                                                                    'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxToolCommand) that implements the new tool.',
                                                                                        'type': ('MFnPlugin',
                                                                                                 'MCreatorFunction')}},
                                                        'args': [('commandName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('creatorFunction',
                                                                  ('MFnPlugin',
                                                                   'MCreatorFunction'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRegister a new context command with Maya. Once registered, the context can be used to create a new  tool  that can be used in a manner identical to built-in Maya tools.',
                                                        'inArgs': ['commandName',
                                                                   'creatorFunction'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'commandName': ['const',
                                                                                           '&'],
                                                                           'creatorFunction': []},
                                                        'types': {'commandName': 'MString',
                                                                  'creatorFunction': ('MFnPlugin',
                                                                                      'MCreatorFunction')}},
                                                       {'argInfo': {'commandName': {'doc': 'the name of the context command to register ',
                                                                                    'type': 'MString'},
                                                                    'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxToolCommand) that implements the new tool. ',
                                                                                        'type': ('MFnPlugin',
                                                                                                 'MCreatorFunction')},
                                                                    'toolCmdCreator': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxToolCommand) that implements the new command. ',
                                                                                       'type': ('MFnPlugin',
                                                                                                'MCreatorFunction')},
                                                                    'toolCmdName': {'doc': 'the name of the tool command to register ',
                                                                                    'type': 'MString'},
                                                                    'toolCmdSyntax': {'doc': 'a pointer to a function that will return a new instance of a syntax object (MSyntax) that implements the syntax of the command.',
                                                                                      'type': ('MFnPlugin',
                                                                                               'MCreateSyntaxFunction')}},
                                                        'args': [('commandName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('creatorFunction',
                                                                  ('MFnPlugin',
                                                                   'MCreatorFunction'),
                                                                  'in'),
                                                                 ('toolCmdName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('toolCmdCreator',
                                                                  ('MFnPlugin',
                                                                   'MCreatorFunction'),
                                                                  'in'),
                                                                 ('toolCmdSyntax',
                                                                  ('MFnPlugin',
                                                                   'MCreateSyntaxFunction'),
                                                                  'in')],
                                                        'defaults': {'toolCmdSyntax': None},
                                                        'deprecated': False,
                                                        'doc': '\r\nRegister a new context command and a new tool command with Maya. This version of registerContextCommand must be used if a tool command (a class derived from  MPxToolCommand ) is used within the context. The method newToolCommand of  MPxContext  will return a new instance of the tool command that can be used in the context.',
                                                        'inArgs': ['commandName',
                                                                   'creatorFunction',
                                                                   'toolCmdName',
                                                                   'toolCmdCreator',
                                                                   'toolCmdSyntax'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'commandName': ['const',
                                                                                           '&'],
                                                                           'creatorFunction': [],
                                                                           'toolCmdCreator': [],
                                                                           'toolCmdName': ['const',
                                                                                           '&'],
                                                                           'toolCmdSyntax': []},
                                                        'types': {'commandName': 'MString',
                                                                  'creatorFunction': ('MFnPlugin',
                                                                                      'MCreatorFunction'),
                                                                  'toolCmdCreator': ('MFnPlugin',
                                                                                     'MCreatorFunction'),
                                                                  'toolCmdName': 'MString',
                                                                  'toolCmdSyntax': ('MFnPlugin',
                                                                                    'MCreateSyntaxFunction')}}],
                            'registerControlCommand': [{'argInfo': {'commandName': {'doc': 'the name of the control to register ',
                                                                                    'type': 'MString'},
                                                                    'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class(derived from MPxControlCommand) that implements the new command.',
                                                                                        'type': ('MFnPlugin',
                                                                                                 'MCreatorFunction')}},
                                                        'args': [('commandName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('creatorFunction',
                                                                  ('MFnPlugin',
                                                                   'MCreatorFunction'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRegister a new control command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.',
                                                        'inArgs': ['commandName',
                                                                   'creatorFunction'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'commandName': ['const',
                                                                                           '&'],
                                                                           'creatorFunction': []},
                                                        'types': {'commandName': 'MString',
                                                                  'creatorFunction': ('MFnPlugin',
                                                                                      'MCreatorFunction')}}],
                            'registerData': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxData) that implements the new data type. ',
                                                                              'type': ('MFnPlugin',
                                                                                       'MCreatorFunction')},
                                                          'type': {'doc': 'the type of data being registered, see the Type enum in MPxData.h for all available types',
                                                                   'type': ('MPxData',
                                                                            'Type')},
                                                          'typeId': {'doc': 'the unique type id of the data type to register ',
                                                                     'type': 'MTypeId'},
                                                          'typeName': {'doc': 'the name of the data type to register ',
                                                                       'type': 'MString'}},
                                              'args': [('typeName',
                                                        'MString',
                                                        'in'),
                                                       ('typeId',
                                                        'MTypeId',
                                                        'in'),
                                                       ('creatorFunction',
                                                        ('MFnPlugin',
                                                         'MCreatorFunction'),
                                                        'in'),
                                                       ('type',
                                                        ('MPxData',
                                                         'Type'),
                                                        'in')],
                                              'defaults': {'type': ('MPxData',
                                                                    'Type',
                                                                    'kData')},
                                              'deprecated': False,
                                              'doc': '\r\nRegister a new data type with Maya. Once registered, the data type can be passed between dependency nodes in a manner identical to built-in Maya data types.',
                                              'inArgs': ['typeName',
                                                         'typeId',
                                                         'creatorFunction',
                                                         'type'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'creatorFunction': [],
                                                                 'type': [],
                                                                 'typeId': ['const',
                                                                            '&'],
                                                                 'typeName': ['const',
                                                                              '&']},
                                              'types': {'creatorFunction': ('MFnPlugin',
                                                                            'MCreatorFunction'),
                                                        'type': ('MPxData',
                                                                 'Type'),
                                                        'typeId': 'MTypeId',
                                                        'typeName': 'MString'}}],
                            'registerDevice': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxMidiInputDevice) that implements the new device.',
                                                                                'type': ('MFnPlugin',
                                                                                         'MCreatorFunction')},
                                                            'deviceName': {'doc': 'the name of the device to register ',
                                                                           'type': 'MString'}},
                                                'args': [('deviceName',
                                                          'MString',
                                                          'in'),
                                                         ('creatorFunction',
                                                          ('MFnPlugin',
                                                           'MCreatorFunction'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRegister a new input device with Maya. Once registered, the new input device can be connected to Maya actions using the  assignInputDevice  command in MEL in a manner identical to built-in Maya devices.  In Maya 1.0, only Midi input devices are supported and the creatorFunction must return a pointer to a  MPxMidiInputDevice  instance. This interface will be generalized in a future release.',
                                                'inArgs': ['deviceName',
                                                           'creatorFunction'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'creatorFunction': [],
                                                                   'deviceName': ['const',
                                                                                  '&']},
                                                'types': {'creatorFunction': ('MFnPlugin',
                                                                              'MCreatorFunction'),
                                                          'deviceName': 'MString'}}],
                            'registerDisplayFilter': [{'argInfo': {'classification': {'doc': 'the classification to filter objects in Viewport 2.0',
                                                                                      'type': 'MString'},
                                                                   'label': {'doc': 'the UI display name of the display filter ',
                                                                             'type': 'MString'},
                                                                   'name': {'doc': 'the new display filter name ',
                                                                            'type': 'MString'}},
                                                       'args': [('name',
                                                                 'MString',
                                                                 'in'),
                                                                ('label',
                                                                 'MString',
                                                                 'in'),
                                                                ('classification',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nRegister a new display filter with Maya.',
                                                       'inArgs': ['name',
                                                                  'label',
                                                                  'classification'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'classification': ['const',
                                                                                             '&'],
                                                                          'label': ['const',
                                                                                    '&'],
                                                                          'name': ['const',
                                                                                   '&']},
                                                       'types': {'classification': 'MString',
                                                                 'label': 'MString',
                                                                 'name': 'MString'}}],
                            'registerDragAndDropBehavior': [{'argInfo': {'behaviorName': {'doc': 'the name of the drag and drop behavior to register ',
                                                                                          'type': 'MString'},
                                                                         'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxDragAndDropBehavior) that implements the new behavior.',
                                                                                             'type': ('MFnPlugin',
                                                                                                      'MCreatorFunction')}},
                                                             'args': [('behaviorName',
                                                                       'MString',
                                                                       'in'),
                                                                      ('creatorFunction',
                                                                       ('MFnPlugin',
                                                                        'MCreatorFunction'),
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nRegister a new drag and drop behavior with Maya. Once registered, the new behavior can be used to finish connections between node drag and drops from the hyperGraph/hyperShade to other nodes or Maya UI.',
                                                             'inArgs': ['behaviorName',
                                                                        'creatorFunction'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'behaviorName': ['const',
                                                                                                 '&'],
                                                                                'creatorFunction': []},
                                                             'types': {'behaviorName': 'MString',
                                                                       'creatorFunction': ('MFnPlugin',
                                                                                           'MCreatorFunction')}}],
                            'registerEvaluator': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the evaluator',
                                                                                   'type': ('MFnPlugin',
                                                                                            'MCreatorFunction')},
                                                               'evaluatorName': {'doc': 'the name of the evaluator ',
                                                                                 'type': 'MString'},
                                                               'uniquePriority': {'doc': 'a priority that needs to be unique. The custom evaluator with highest priority order will get the chance to claim nodes first. ',
                                                                                  'type': 'uint'}},
                                                   'args': [('evaluatorName',
                                                             'MString',
                                                             'in'),
                                                            ('uniquePriority',
                                                             'uint',
                                                             'in'),
                                                            ('creatorFunction',
                                                             ('MFnPlugin',
                                                              'MCreatorFunction'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRegister a new evaluator with Maya. Once registered, the evaluator can be turned on and off via the command line like any other evaluator.',
                                                   'inArgs': ['evaluatorName',
                                                              'uniquePriority',
                                                              'creatorFunction'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'creatorFunction': [],
                                                                      'evaluatorName': ['const',
                                                                                        '&'],
                                                                      'uniquePriority': ['unsigned']},
                                                   'types': {'creatorFunction': ('MFnPlugin',
                                                                                 'MCreatorFunction'),
                                                             'evaluatorName': 'MString',
                                                             'uniquePriority': 'uint'}}],
                            'registerFileTranslator': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxFileTranslator) that implements the new file type. ',
                                                                                        'type': ('MFnPlugin',
                                                                                                 'MCreatorFunction')},
                                                                    'dataStorageLocation': {'doc': 'the default location where this translator will store its data relative to the current project. This defaults to MFnPlugin::kDefaultDataLocation The translator command parameter -defaultFileRule will return this value.',
                                                                                            'type': 'MString'},
                                                                    'defaultOptionsString': {'doc': 'the default value of the options string that will be passed to the options script. ',
                                                                                             'type': 'char'},
                                                                    'optionsScriptName': {'doc': 'the name of a MEL script that will be used to display the contents of the options dialog during file open and save. ',
                                                                                          'type': 'char'},
                                                                    'pixmapName': {'doc': 'the pathname of the icon used in file selection dialogs ',
                                                                                   'type': 'char'},
                                                                    'requiresFullMel': {'doc': 'this should be set to true if the reader method in the derived class intends to issue MEL commands via the MGlobal::executeCommand method. Setting this to true will slow down the creation of new objects, but allows MEL commands other than those that are part of the Maya Ascii file format to function correctly. This parameter defaults to false.',
                                                                                        'type': 'bool'},
                                                                    'translatorName': {'doc': 'the string by which Maya will refer to this file type ',
                                                                                       'type': 'MString'}},
                                                        'args': [('translatorName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('pixmapName',
                                                                  'char',
                                                                  'in'),
                                                                 ('creatorFunction',
                                                                  ('MFnPlugin',
                                                                   'MCreatorFunction'),
                                                                  'in'),
                                                                 ('optionsScriptName',
                                                                  'char',
                                                                  'in'),
                                                                 ('defaultOptionsString',
                                                                  'char',
                                                                  'in'),
                                                                 ('requiresFullMel',
                                                                  'bool',
                                                                  'in'),
                                                                 ('dataStorageLocation',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {'dataStorageLocation': 'MFnPlugin::kDefaultDataLocation',
                                                                     'defaultOptionsString': None,
                                                                     'optionsScriptName': None,
                                                                     'requiresFullMel': False},
                                                        'deprecated': False,
                                                        'doc': '\r\nRegister a new file translator with Maya.',
                                                        'inArgs': ['translatorName',
                                                                   'pixmapName',
                                                                   'creatorFunction',
                                                                   'optionsScriptName',
                                                                   'defaultOptionsString',
                                                                   'requiresFullMel',
                                                                   'dataStorageLocation'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'creatorFunction': [],
                                                                           'dataStorageLocation': [],
                                                                           'defaultOptionsString': ['const',
                                                                                                    '*'],
                                                                           'optionsScriptName': ['const',
                                                                                                 '*'],
                                                                           'pixmapName': ['const',
                                                                                          '*'],
                                                                           'requiresFullMel': [],
                                                                           'translatorName': ['const',
                                                                                              '&']},
                                                        'types': {'creatorFunction': ('MFnPlugin',
                                                                                      'MCreatorFunction'),
                                                                  'dataStorageLocation': 'MString',
                                                                  'defaultOptionsString': 'char',
                                                                  'optionsScriptName': 'char',
                                                                  'pixmapName': 'char',
                                                                  'requiresFullMel': 'bool',
                                                                  'translatorName': 'MString'}}],
                            'registerIkSolver': [{'argInfo': {'creatorFunction': {'doc': 'pointer to a function that will return a pointer to a new instance of the class (derived from MPxIkSolver) that implements the new file type.',
                                                                                  'type': ('MFnPlugin',
                                                                                           'MCreatorFunction')},
                                                              'ikSolverName': {'doc': 'name of the new IK solver ',
                                                                               'type': 'MString'}},
                                                  'args': [('ikSolverName',
                                                            'MString',
                                                            'in'),
                                                           ('creatorFunction',
                                                            ('MFnPlugin',
                                                             'MCreatorFunction'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRegister a new ik-solver with Maya. NOTE: this method is obsolete. Instead, register the IK solver as a node as described in the example plug-in simpleSolverNode.cpp.',
                                                  'inArgs': ['ikSolverName',
                                                             'creatorFunction'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'creatorFunction': [],
                                                                     'ikSolverName': ['const',
                                                                                      '&']},
                                                  'types': {'creatorFunction': ('MFnPlugin',
                                                                                'MCreatorFunction'),
                                                            'ikSolverName': 'MString'}}],
                            'registerImageFile': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MImageFile) that implements the new file type. ',
                                                                                   'type': ('MFnPlugin',
                                                                                            'MCreatorFunction')},
                                                               'imageFileExtensions': {'doc': 'this list of file extensions this image file should be associated with.',
                                                                                       'type': 'MStringArray'},
                                                               'imageFormatName': {'doc': 'the name of the image format to register ',
                                                                                   'type': 'MString'}},
                                                   'args': [('imageFormatName',
                                                             'MString',
                                                             'in'),
                                                            ('creatorFunction',
                                                             ('MFnPlugin',
                                                              'MCreatorFunction'),
                                                             'in'),
                                                            ('imageFileExtensions',
                                                             'MStringArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRegister a new image file translator with Maya.',
                                                   'inArgs': ['imageFormatName',
                                                              'creatorFunction',
                                                              'imageFileExtensions'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'creatorFunction': [],
                                                                      'imageFileExtensions': ['const',
                                                                                              '&'],
                                                                      'imageFormatName': ['const',
                                                                                          '&']},
                                                   'types': {'creatorFunction': ('MFnPlugin',
                                                                                 'MCreatorFunction'),
                                                             'imageFileExtensions': 'MStringArray',
                                                             'imageFormatName': 'MString'}}],
                            'registerMaterialInfo': [{'argInfo': {'fnPtr': {'doc': 'pointer to function that return a new instance of material information node.',
                                                                            'type': 'MMaterialInfoFactoryFnPtr'},
                                                                  'materialInfoName': {'doc': 'the new material info generator name. ',
                                                                                       'type': 'MString'}},
                                                      'args': [('materialInfoName',
                                                                'MString',
                                                                'in'),
                                                               ('fnPtr',
                                                                'MMaterialInfoFactoryFnPtr',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nRegisters a new material information type with Maya.',
                                                      'inArgs': ['materialInfoName',
                                                                 'fnPtr'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'fnPtr': [],
                                                                         'materialInfoName': ['const',
                                                                                              '&']},
                                                      'types': {'fnPtr': 'MMaterialInfoFactoryFnPtr',
                                                                'materialInfoName': 'MString'}}],
                            'registerModelEditorCommand': [{'argInfo': {'commandName': {'doc': 'the name of the command to register ',
                                                                                        'type': 'MString'},
                                                                        'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxEditorCommand) that implements the new command. ',
                                                                                            'type': ('MFnPlugin',
                                                                                                     'MCreatorFunction')},
                                                                        'viewCreatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPx3dModelView) that implemented the new view associated with this command.',
                                                                                                'type': ('MFnPlugin',
                                                                                                         'MCreatorFunction')}},
                                                            'args': [('commandName',
                                                                      'MString',
                                                                      'in'),
                                                                     ('creatorFunction',
                                                                      ('MFnPlugin',
                                                                       'MCreatorFunction'),
                                                                      'in'),
                                                                     ('viewCreatorFunction',
                                                                      ('MFnPlugin',
                                                                       'MCreatorFunction'),
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nRegister a new model editor command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.',
                                                            'inArgs': ['commandName',
                                                                       'creatorFunction',
                                                                       'viewCreatorFunction'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'commandName': ['const',
                                                                                               '&'],
                                                                               'creatorFunction': [],
                                                                               'viewCreatorFunction': []},
                                                            'types': {'commandName': 'MString',
                                                                      'creatorFunction': ('MFnPlugin',
                                                                                          'MCreatorFunction'),
                                                                      'viewCreatorFunction': ('MFnPlugin',
                                                                                              'MCreatorFunction')}}],
                            'registerNode': [{'argInfo': {'classification': {'doc': 'a string that determines how the node will be categorized in various rendering-related UI, such as the Create Render Node and HyperShade windows. See the documentation for the getClassification command for a list of the supported classifications. If no string is supplied then the node will not be considered a rendering node and will not be displayed in those UI. The classification also allows the node type to be recognized as a shape with Viewport 2.0. A classification string which starts with "drawdb/geometry" (plus any further subclassifications) is required. Note that adding the subclassification "transform" immediately after "geometry" will indicate that this is a transform instead of shape. See the documentation for registerTransform().',
                                                                             'type': 'MString'},
                                                          'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxNode) that implements the new node type ',
                                                                              'type': ('MFnPlugin',
                                                                                       'MCreatorFunction')},
                                                          'initFunction': {'doc': 'a pointer to a function that will initialize all the attributes of the new node type ',
                                                                           'type': ('MFnPlugin',
                                                                                    'MInitializeFunction')},
                                                          'type': {'doc': 'the type of plugin node to be registered ',
                                                                   'type': ('MPxNode',
                                                                            'Type')},
                                                          'typeId': {'doc': 'a unique id that identifies this node ',
                                                                     'type': 'MTypeId'},
                                                          'typeName': {'doc': 'the name of the new type of node ',
                                                                       'type': 'MString'}},
                                              'args': [('typeName',
                                                        'MString',
                                                        'in'),
                                                       ('typeId',
                                                        'MTypeId',
                                                        'in'),
                                                       ('creatorFunction',
                                                        ('MFnPlugin',
                                                         'MCreatorFunction'),
                                                        'in'),
                                                       ('initFunction',
                                                        ('MFnPlugin',
                                                         'MInitializeFunction'),
                                                        'in'),
                                                       ('type',
                                                        ('MPxNode',
                                                         'Type'),
                                                        'in'),
                                                       ('classification',
                                                        'MString',
                                                        'in')],
                                              'defaults': {'classification': None,
                                                           'type': ('MPxNode',
                                                                    'Type',
                                                                    'kDependNode')},
                                              'deprecated': False,
                                              'doc': '\r\nRegister a new dependency node with Maya. Once registered, the node can be used from MEL in a manner identical to built-in Maya nodes.',
                                              'inArgs': ['typeName',
                                                         'typeId',
                                                         'creatorFunction',
                                                         'initFunction',
                                                         'type',
                                                         'classification'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'classification': ['const',
                                                                                    '*'],
                                                                 'creatorFunction': [],
                                                                 'initFunction': [],
                                                                 'type': [],
                                                                 'typeId': ['const',
                                                                            '&'],
                                                                 'typeName': ['const',
                                                                              '&']},
                                              'types': {'classification': 'MString',
                                                        'creatorFunction': ('MFnPlugin',
                                                                            'MCreatorFunction'),
                                                        'initFunction': ('MFnPlugin',
                                                                         'MInitializeFunction'),
                                                        'type': ('MPxNode',
                                                                 'Type'),
                                                        'typeId': 'MTypeId',
                                                        'typeName': 'MString'}}],
                            'registerRenderPassImpl': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxRenderPassImpl) that implements the render pass definiton. ',
                                                                                        'type': ('MFnPlugin',
                                                                                                 'MCreatorFunction')},
                                                                    'overload': {'doc': 'Override any existing implementation in the registry',
                                                                                 'type': 'bool'},
                                                                    'passDef': {'doc': 'the render pass definition to associate this implementation with ',
                                                                                'type': 'MRenderPassDef'},
                                                                    'passImplId': {'doc': 'a unique name identifying the pass implementation ',
                                                                                   'type': 'MString'}},
                                                        'args': [('passImplId',
                                                                  'MString',
                                                                  'in'),
                                                                 ('passDef',
                                                                  'MRenderPassDef',
                                                                  'in'),
                                                                 ('creatorFunction',
                                                                  ('MFnPlugin',
                                                                   'MCreatorFunction'),
                                                                  'in'),
                                                                 ('overload',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {'overload': False},
                                                        'deprecated': False,
                                                        'doc': '\r\nRegister a new render pass implementation with Maya and associate with the given render pass definition. If an implementation with id passImplId has already been registered and creatorFunction is the same as the already registered creator function then the existing implementation will also be used for the current pass (SAME instances). It is an error if the passImplId is already defined and a different creatorFunction is used. If you wish to associate DIFFERENT instances of the same pass implementation with different passes, then use unique passImplIds when registering each.',
                                                        'inArgs': ['passImplId',
                                                                   'passDef',
                                                                   'creatorFunction',
                                                                   'overload'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'creatorFunction': [],
                                                                           'overload': [],
                                                                           'passDef': ['*'],
                                                                           'passImplId': ['const',
                                                                                          '&']},
                                                        'types': {'creatorFunction': ('MFnPlugin',
                                                                                      'MCreatorFunction'),
                                                                  'overload': 'bool',
                                                                  'passDef': 'MRenderPassDef',
                                                                  'passImplId': 'MString'}}],
                            'registerRenderer': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxRenderer) that implements the new renderer.',
                                                                                  'type': ('MFnPlugin',
                                                                                           'MCreatorFunction')},
                                                              'name': {'doc': 'The name of the renderer ',
                                                                       'type': 'MString'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in'),
                                                           ('creatorFunction',
                                                            ('MFnPlugin',
                                                             'MCreatorFunction'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRegisters a new renderer identified by name.',
                                                  'inArgs': ['name',
                                                             'creatorFunction'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'creatorFunction': [],
                                                                     'name': ['const',
                                                                              '&']},
                                                  'types': {'creatorFunction': ('MFnPlugin',
                                                                                'MCreatorFunction'),
                                                            'name': 'MString'}}],
                            'registerShape': [{'argInfo': {'classification': {'doc': 'a string that determines how the node will be categorized in various rendering-related UI, such as the Create Render Node and HyperShade windows. See the documentation for the getClassification command for a list of the supported classifications. If no string is supplied then the node will not be considered a rendering node and will not be displayed in those UI. The classification also allows the node type to be recognized as a shape with Viewport 2.0. A classification string which starts with "drawdb/geometry" (plus any further subclassifications) is required. Note that adding the subclassification "transform" immediately after "geometry" will indicate that this is a transform instead of shape. See the documentation for registerTransform().',
                                                                              'type': 'MString'},
                                                           'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxSurfaceNode) that implements the new shape node type ',
                                                                               'type': ('MFnPlugin',
                                                                                        'MCreatorFunction')},
                                                           'initFunction': {'doc': 'a pointer to a function that will initialize all the attributes of the new shape node type ',
                                                                            'type': ('MFnPlugin',
                                                                                     'MInitializeFunction')},
                                                           'typeId': {'doc': 'a unique id that identifies this node ',
                                                                      'type': 'MTypeId'},
                                                           'typeName': {'doc': 'the name of the new type of user defined shape node ',
                                                                        'type': 'MString'},
                                                           'uiCreatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MGxSurfaceShapeUI) that is used to implement the drawing and selection functions of the user defined shape. ',
                                                                                 'type': ('MFnPlugin',
                                                                                          'MCreatorFunction')}},
                                               'args': [('typeName',
                                                         'MString',
                                                         'in'),
                                                        ('typeId',
                                                         'MTypeId',
                                                         'in'),
                                                        ('creatorFunction',
                                                         ('MFnPlugin',
                                                          'MCreatorFunction'),
                                                         'in'),
                                                        ('initFunction',
                                                         ('MFnPlugin',
                                                          'MInitializeFunction'),
                                                         'in'),
                                                        ('uiCreatorFunction',
                                                         ('MFnPlugin',
                                                          'MCreatorFunction'),
                                                         'in'),
                                                        ('classification',
                                                         'MString',
                                                         'in')],
                                               'defaults': {'classification': None},
                                               'deprecated': False,
                                               'doc': '\r\nRegisters the given user defined shape node with Maya. Once registered, the shape can be used from MEL in a manner identical to built-in Maya nodes.',
                                               'inArgs': ['typeName',
                                                          'typeId',
                                                          'creatorFunction',
                                                          'initFunction',
                                                          'uiCreatorFunction',
                                                          'classification'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'classification': ['const',
                                                                                     '*'],
                                                                  'creatorFunction': [],
                                                                  'initFunction': [],
                                                                  'typeId': ['const',
                                                                             '&'],
                                                                  'typeName': ['const',
                                                                               '&'],
                                                                  'uiCreatorFunction': []},
                                               'types': {'classification': 'MString',
                                                         'creatorFunction': ('MFnPlugin',
                                                                             'MCreatorFunction'),
                                                         'initFunction': ('MFnPlugin',
                                                                          'MInitializeFunction'),
                                                         'typeId': 'MTypeId',
                                                         'typeName': 'MString',
                                                         'uiCreatorFunction': ('MFnPlugin',
                                                                               'MCreatorFunction')}}],
                            'registerTransform': [{'argInfo': {'classification': {'doc': 'a string that determines how the node will be categorized in various rendering-related UI, such as the Create Render Node and HyperShade windows. See the documentation for the getClassification command for a list of the supported classifications. If no string is supplied then the node will not be considered a rendering node and will not be displayed in those UI. The classification also allows the node type to be recognized as a transform with Viewport 2.0. A classification string which starts with "drawdb/geometry/transform" (plus any further subclassifications) is required. If this classification is not specified then it will automatically be added for this node type.',
                                                                                  'type': 'MString'},
                                                               'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxTransform) that implements the new transform node type ',
                                                                                   'type': ('MFnPlugin',
                                                                                            'MCreatorFunction')},
                                                               'initFunction': {'doc': 'a pointer to a function that will initialize all the attributes of the new transform node type ',
                                                                                'type': ('MFnPlugin',
                                                                                         'MInitializeFunction')},
                                                               'typeId': {'doc': 'a unique id that identifies this node ',
                                                                          'type': 'MTypeId'},
                                                               'typeName': {'doc': 'the name of the new type of user defined transform node ',
                                                                            'type': 'MString'},
                                                               'xformCreatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the class (derived from MPxTransformationMatrix) that is used to implement the matrix functions of the custom transform. For default behavior, use the MPxTransformationMatrix::creator method. ',
                                                                                        'type': ('MFnPlugin',
                                                                                                 'MCreateXformMatrixFunction')},
                                                               'xformId': {'doc': 'a unique id that identifies this transformation matrix. If MPxTransformationMatrix::creator is used, then MPxTransformationMatrix::baseTransformationMatrixId should be used. ',
                                                                           'type': 'MTypeId'}},
                                                   'args': [('typeName',
                                                             'MString',
                                                             'in'),
                                                            ('typeId',
                                                             'MTypeId',
                                                             'in'),
                                                            ('creatorFunction',
                                                             ('MFnPlugin',
                                                              'MCreatorFunction'),
                                                             'in'),
                                                            ('initFunction',
                                                             ('MFnPlugin',
                                                              'MInitializeFunction'),
                                                             'in'),
                                                            ('xformCreatorFunction',
                                                             ('MFnPlugin',
                                                              'MCreateXformMatrixFunction'),
                                                             'in'),
                                                            ('xformId',
                                                             'MTypeId',
                                                             'in'),
                                                            ('classification',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {'classification': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nRegisters the given user defined transform node with Maya. Once registered, the transform can be used from MEL in a manner identical to built-in Maya nodes.',
                                                   'inArgs': ['typeName',
                                                              'typeId',
                                                              'creatorFunction',
                                                              'initFunction',
                                                              'xformCreatorFunction',
                                                              'xformId',
                                                              'classification'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'classification': ['const',
                                                                                         '*'],
                                                                      'creatorFunction': [],
                                                                      'initFunction': [],
                                                                      'typeId': ['const',
                                                                                 '&'],
                                                                      'typeName': ['const',
                                                                                   '&'],
                                                                      'xformCreatorFunction': [],
                                                                      'xformId': ['const',
                                                                                  '&']},
                                                   'types': {'classification': 'MString',
                                                             'creatorFunction': ('MFnPlugin',
                                                                                 'MCreatorFunction'),
                                                             'initFunction': ('MFnPlugin',
                                                                              'MInitializeFunction'),
                                                             'typeId': 'MTypeId',
                                                             'typeName': 'MString',
                                                             'xformCreatorFunction': ('MFnPlugin',
                                                                                      'MCreateXformMatrixFunction'),
                                                             'xformId': 'MTypeId'}},
                                                  {'argInfo': {'classification': {'doc': '',
                                                                                  'type': 'MString'},
                                                               'creatorFunction': {'doc': '',
                                                                                   'type': ('MFnPlugin',
                                                                                            'MCreatorFunction')},
                                                               'initFunction': {'doc': '',
                                                                                'type': ('MFnPlugin',
                                                                                         'MInitializeFunction')},
                                                               'typeId': {'doc': '',
                                                                          'type': 'MTypeId'},
                                                               'typeName': {'doc': '',
                                                                            'type': 'MString'},
                                                               'xformCreatorFunction': {'doc': '',
                                                                                        'type': ('MFnPlugin',
                                                                                                 'MCreatorFunction')},
                                                               'xformId': {'doc': '',
                                                                           'type': 'MTypeId'}},
                                                   'args': [('typeName',
                                                             'MString',
                                                             'in'),
                                                            ('typeId',
                                                             'MTypeId',
                                                             'in'),
                                                            ('creatorFunction',
                                                             ('MFnPlugin',
                                                              'MCreatorFunction'),
                                                             'in'),
                                                            ('initFunction',
                                                             ('MFnPlugin',
                                                              'MInitializeFunction'),
                                                             'in'),
                                                            ('xformCreatorFunction',
                                                             ('MFnPlugin',
                                                              'MCreatorFunction'),
                                                             'in'),
                                                            ('xformId',
                                                             'MTypeId',
                                                             'in'),
                                                            ('classification',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {'classification': None},
                                                   'deprecated': True,
                                                   'doc': '\r\nObsolete. \r\n',
                                                   'inArgs': ['typeName',
                                                              'typeId',
                                                              'creatorFunction',
                                                              'initFunction',
                                                              'xformCreatorFunction',
                                                              'xformId',
                                                              'classification'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'classification': ['const',
                                                                                         '*'],
                                                                      'creatorFunction': [],
                                                                      'initFunction': [],
                                                                      'typeId': ['const',
                                                                                 '&'],
                                                                      'typeName': ['const',
                                                                                   '&'],
                                                                      'xformCreatorFunction': [],
                                                                      'xformId': ['const',
                                                                                  '&']},
                                                   'types': {'classification': 'MString',
                                                             'creatorFunction': ('MFnPlugin',
                                                                                 'MCreatorFunction'),
                                                             'initFunction': ('MFnPlugin',
                                                                              'MInitializeFunction'),
                                                             'typeId': 'MTypeId',
                                                             'typeName': 'MString',
                                                             'xformCreatorFunction': ('MFnPlugin',
                                                                                      'MCreatorFunction'),
                                                             'xformId': 'MTypeId'}}],
                            'registerUI': [{'argInfo': {'creationBatchProc': {'doc': 'The name of the Python callable object to be run when the plug in is loaded in batch mode. The procedure should not contain UI related code. ',
                                                                              'type': ('MFnPlugin',
                                                                                       'PyObject')},
                                                        'creationProc': {'doc': 'The name of the Python callable object to be run when the plug in is loaded ',
                                                                         'type': ('MFnPlugin',
                                                                                  'PyObject')},
                                                        'deletionBatchProc': {'doc': 'The name of the Python callable object to be run when the plug in is unloaded in batch mode. The procedure should not contain UI related code.',
                                                                              'type': ('MFnPlugin',
                                                                                       'PyObject')},
                                                        'deletionProc': {'doc': 'The name of the Python callable object to be run when the plug in is unloaded ',
                                                                         'type': ('MFnPlugin',
                                                                                  'PyObject')}},
                                            'args': [('creationProc',
                                                      ('MFnPlugin',
                                                       'PyObject'),
                                                      'in'),
                                                     ('deletionProc',
                                                      ('MFnPlugin',
                                                       'PyObject'),
                                                      'in'),
                                                     ('creationBatchProc',
                                                      ('MFnPlugin',
                                                       'PyObject'),
                                                      'in'),
                                                     ('deletionBatchProc',
                                                      ('MFnPlugin',
                                                       'PyObject'),
                                                      'in')],
                                            'defaults': {'creationBatchProc': None,
                                                         'deletionBatchProc': None},
                                            'deprecated': False,
                                            'doc': '\r\nSets the Python callable objects to be called to create and destroy any UI associated with the plugin.',
                                            'inArgs': ['creationProc',
                                                       'deletionProc',
                                                       'creationBatchProc',
                                                       'deletionBatchProc'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'creationBatchProc': ['*'],
                                                               'creationProc': ['*'],
                                                               'deletionBatchProc': ['*'],
                                                               'deletionProc': ['*']},
                                            'types': {'creationBatchProc': ('MFnPlugin',
                                                                            'PyObject'),
                                                      'creationProc': ('MFnPlugin',
                                                                       'PyObject'),
                                                      'deletionBatchProc': ('MFnPlugin',
                                                                            'PyObject'),
                                                      'deletionProc': ('MFnPlugin',
                                                                       'PyObject')}},
                                           {'argInfo': {'creationBatchProc': {'doc': 'The name of the procedure to be run when the plug in is loaded in batch mode. The procedure should not contain UI related code. ',
                                                                              'type': 'MString'},
                                                        'creationProc': {'doc': 'The name of the procedure to be run when the plug in is loaded ',
                                                                         'type': 'MString'},
                                                        'deletionBatchProc': {'doc': 'The name of the procedure to be run when the plug in is unloaded in batch mode. The procedure should not contain UI related code.',
                                                                              'type': 'MString'},
                                                        'deletionProc': {'doc': 'The name of the procedure to be run when the plug in is unloaded ',
                                                                         'type': 'MString'}},
                                            'args': [('creationProc',
                                                      'MString',
                                                      'in'),
                                                     ('deletionProc',
                                                      'MString',
                                                      'in'),
                                                     ('creationBatchProc',
                                                      'MString',
                                                      'in'),
                                                     ('deletionBatchProc',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'creationBatchProc': '""',
                                                         'deletionBatchProc': '""'},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['creationProc',
                                                       'deletionProc',
                                                       'creationBatchProc',
                                                       'deletionBatchProc'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'creationBatchProc': ['const',
                                                                                     '&'],
                                                               'creationProc': ['const',
                                                                                '&'],
                                                               'deletionBatchProc': ['const',
                                                                                     '&'],
                                                               'deletionProc': ['const',
                                                                                '&']},
                                            'types': {'creationBatchProc': 'MString',
                                                      'creationProc': 'MString',
                                                      'deletionBatchProc': 'MString',
                                                      'deletionProc': 'MString'}}],
                            'registerUIStrings': [{'argInfo': {'pluginStringsProc': {'doc': 'The name of the mel procedure to be run during plugin load to register script-based resources. This script will also make the necessary calls to load localized string values if they exist.',
                                                                                     'type': 'MString'},
                                                               'registerMStringResources': {'doc': 'This callback is used to register MStringResources that are used by the plugin code. The callback signature type is defined by MInitializeFunction. ',
                                                                                            'type': ('MFnPlugin',
                                                                                                     'MInitializeFunction')}},
                                                   'args': [('registerMStringResources',
                                                             ('MFnPlugin',
                                                              'MInitializeFunction'),
                                                             'in'),
                                                            ('pluginStringsProc',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the callback and procedure names of routines that register plugin string resources and optionally load localized values for them.',
                                                   'inArgs': ['registerMStringResources',
                                                              'pluginStringsProc'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'pluginStringsProc': ['const',
                                                                                            '&'],
                                                                      'registerMStringResources': []},
                                                   'types': {'pluginStringsProc': 'MString',
                                                             'registerMStringResources': ('MFnPlugin',
                                                                                          'MInitializeFunction')}}],
                            'registerURIFileResolver': [{'argInfo': {'creatorFunction': {'doc': 'Pointer to a function that will return a pointer to a new instance of the class (derived from MPxFileResolver) that implements the new file type.',
                                                                                         'type': ('MFnPlugin',
                                                                                                  'MCreatorFunction')},
                                                                     'fileResolverName': {'doc': 'Name of new file resolver to register. ',
                                                                                          'type': 'MString'},
                                                                     'uriScheme': {'doc': 'URI scheme this resolver supports. ',
                                                                                   'type': 'MString'}},
                                                         'args': [('fileResolverName',
                                                                   'MString',
                                                                   'in'),
                                                                  ('uriScheme',
                                                                   'MString',
                                                                   'in'),
                                                                  ('creatorFunction',
                                                                   ('MFnPlugin',
                                                                    'MCreatorFunction'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nRegister a Custom URI File Resolver with Maya.',
                                                         'inArgs': ['fileResolverName',
                                                                    'uriScheme',
                                                                    'creatorFunction'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'creatorFunction': [],
                                                                            'fileResolverName': ['const',
                                                                                                 '&'],
                                                                            'uriScheme': ['const',
                                                                                          '&']},
                                                         'types': {'creatorFunction': ('MFnPlugin',
                                                                                       'MCreatorFunction'),
                                                                   'fileResolverName': 'MString',
                                                                   'uriScheme': 'MString'}}],
                            'registeringCallableScript': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturn true if this  MFnPlugin  object has its callbacks defined in script. \r\n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                            'removeMenuItem': [{'argInfo': {'menuItemNames': {'doc': 'Names of the menuItem which needs to be removed.',
                                                                              'type': 'MStringArray'}},
                                                'args': [('menuItemNames',
                                                          'MStringArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThe function removes the menuItem and the corresponding option box, if exists, from the UI.',
                                                'inArgs': ['menuItemNames'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'menuItemNames': ['&']},
                                                'types': {'menuItemNames': 'MStringArray'}}],
                            'setName': [{'argInfo': {'makeUnique': {'doc': 'if true and the requested name is already in use, then Maya will create an unused name for this plug-in. If false, and the name is in use, do not change the current name.',
                                                                    'type': 'bool'},
                                                     'newName': {'doc': 'the new name ',
                                                                 'type': 'MString'}},
                                         'args': [('newName',
                                                   'MString',
                                                   'in'),
                                                  ('makeUnique',
                                                   'bool',
                                                   'in')],
                                         'defaults': {'makeUnique': True},
                                         'deprecated': False,
                                         'doc': '\r\nSet the name by which Maya knows this plug-in.',
                                         'inArgs': ['newName',
                                                    'makeUnique'],
                                         'inverse': ('name', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'makeUnique': [],
                                                            'newName': ['const',
                                                                        '&']},
                                         'types': {'makeUnique': 'bool',
                                                   'newName': 'MString'}}],
                            'setRegisteringCallableScript': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nMark this  MFnPlugin  object as one that will be passed callbacks defined in script. \r\n',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': True,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                            'setVersion': [{'argInfo': {'newVersion': {'doc': 'the new version',
                                                                       'type': 'MString'}},
                                            'args': [('newVersion',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the version name for this plug-in.',
                                            'inArgs': ['newVersion'],
                                            'inverse': ('version', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'newVersion': ['const',
                                                                              '&']},
                                            'types': {'newVersion': 'MString'}}],
                            'type': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn the type of this function set.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': ('MFn',
                                                              'Type')},
                                      'returnType': ('MFn', 'Type'),
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                            'unregisterBakeEngine': [{'argInfo': {'bakeEngineGenName': {'doc': 'the bake engine generator name.',
                                                                                        'type': 'MString'}},
                                                      'args': [('bakeEngineGenName',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nDeregister the bake engine type with Maya.',
                                                      'inArgs': ['bakeEngineGenName'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'bakeEngineGenName': ['const',
                                                                                               '&']},
                                                      'types': {'bakeEngineGenName': 'MString'}}],
                            'unregisterMaterialInfo': [{'argInfo': {'materialInfoName': {'doc': 'the material info generator name.',
                                                                                         'type': 'MString'}},
                                                        'args': [('materialInfoName',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nDeregister the specified material info type with Maya.',
                                                        'inArgs': ['materialInfoName'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'materialInfoName': ['const',
                                                                                                '&']},
                                                        'types': {'materialInfoName': 'MString'}}],
                            'vendor': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturn the vendor string supplied in the  MFnPlugin  constructor.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'An MString containing the vendor name',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                            'version': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the version string supplied in the  MFnPlugin  constructor.',
                                         'inArgs': [],
                                         'inverse': ('setVersion', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'An MString containing the version string',
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}]},
                'pymelEnums': {},
                'pymelMethods': {'name': 'getName',
                                 'registeringCallableScript': 'getRegisteringCallableScript',
                                 'version': 'getVersion'}},
  'MFnPluginData': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'constData': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn a constant pointer to the user defined data held in this instance.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A constant pointer to the MPxData base class for the user defined data ',
                                                              'qualifiers': ['*'],
                                                              'type': 'MPxData'},
                                               'returnType': 'MPxData',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                'create': [{'argInfo': {'id': {'doc': 'the unique MTypeId of the user defined data class derived from MPxData. ',
                                                               'type': 'MTypeId'}},
                                            'args': [('id',
                                                      'MTypeId',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreate an instance of MPluginData and initialize it to represent user defined data of the given type.',
                                            'inArgs': ['id'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'An MObject that represents an instance of the user defined data type. This will be set to MObject::kNullObj if the create failes. ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'id': ['const',
                                                                      '&']},
                                            'types': {'id': 'MTypeId'}}],
                                'data': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturn a pointer to the user defined data held in this instance.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A pointer to the MPxData base class for the user defined data ',
                                                         'qualifiers': ['*'],
                                                         'type': 'MPxData'},
                                          'returnType': 'MPxData',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'typeId': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the unique  MTypeId  of the user defined data that is held by this instance.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The unique MTypeId of the data held in this instance ',
                                                           'qualifiers': [],
                                                           'type': 'MTypeId'},
                                            'returnType': 'MTypeId',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}]},
                    'pymelEnums': {}},
  'MFnPointArrayData': {'enums': {},
                        'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the MPoint to extract',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The indicated MPoint ',
                                                                    'qualifiers': ['&'],
                                                                    'type': 'MPoint'},
                                                     'returnType': 'MPoint',
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}},
                                                    {'argInfo': {'index': {'doc': 'the index of the MPoint to extract',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The indicated MPoint ',
                                                                    'qualifiers': ['&'],
                                                                    'type': 'MPoint'},
                                                     'returnType': 'MPoint',
                                                     'static': False,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}}],
                                    'array': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet an  MPointArray  containing the points stored in this instance. The  MPointArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A copy of the MPointArray held in this instance ',
                                                              'qualifiers': [],
                                                              'type': 'MPointArray'},
                                               'returnType': 'MPointArray',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nClass name. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'copyTo': [{'argInfo': {'dest': {'doc': 'the MPointArray to populate',
                                                                     'type': 'MPointArray'}},
                                                'args': [('dest',
                                                          'MPointArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCopy all the points in the instance into the given  MPointArray . No checking is done by this class on sizes, so it is up to the user to ensure that the given  MPointArray  is large enough to hold the number of MPoints in the instance.',
                                                'inArgs': [],
                                                'outArgs': ['dest'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'dest': ['&']},
                                                'types': {'dest': 'MPointArray'}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to contain no points.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The newly created MObject ',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}},
                                               {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                    'type': 'MPointArray'}},
                                                'args': [('arr',
                                                          'MPointArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MPointArray .',
                                                'inArgs': ['arr'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The newly created MObject ',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'arr': ['const',
                                                                           '&']},
                                                'types': {'arr': 'MPointArray'}}],
                                    'length': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the number of points in the instance.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of points in the instance ',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                    'set': [{'argInfo': {'element': {'doc': 'the element to be set ',
                                                                     'type': 'MPoint'},
                                                         'index': {'doc': 'the index of the MPoint to set',
                                                                   'type': 'uint'}},
                                             'args': [('element',
                                                       'MPoint',
                                                       'in'),
                                                      ('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the point element at the specified index.',
                                             'inArgs': ['element',
                                                        'index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'element': ['&'],
                                                                'index': ['unsigned']},
                                             'types': {'element': 'MPoint',
                                                       'index': 'uint'}},
                                            {'argInfo': {'array': {'doc': 'the MPointArray containing the data to set into this instance',
                                                                   'type': 'MPointArray'}},
                                             'args': [('array',
                                                       'MPointArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the instance to contain the points defined in the given  MPointArray .',
                                             'inArgs': ['array'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'array': ['const',
                                                                          '&']},
                                             'types': {'array': 'MPointArray'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFunction set type. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFnPointLight': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                      'type': 'bool'}},
                                            'args': [('UIvisible',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'UIvisible': True},
                                            'deprecated': False,
                                            'doc': '\r\nCreates a new point light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                            'inArgs': ['UIvisible'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'UIvisible': []},
                                            'types': {'UIvisible': 'bool'}},
                                           {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                      'type': 'bool'},
                                                        'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                   'type': 'MObject'},
                                                        'wantTransform': {'doc': "Boolean to indicate whether the transform node is needed or not, which is 'false' by default. ",
                                                                          'type': 'bool'}},
                                            'args': [('parent',
                                                      'MObject',
                                                      'in'),
                                                     ('UIvisible',
                                                      'bool',
                                                      'in'),
                                                     ('wantTransform',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'UIvisible': True,
                                                         'wantTransform': False},
                                            'deprecated': False,
                                            'doc': '\r\nCreates a new point light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                            'inArgs': ['parent',
                                                       'UIvisible',
                                                       'wantTransform'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'UIvisible': [],
                                                               'parent': ['const',
                                                                          '&'],
                                                               'wantTransform': []},
                                            'types': {'UIvisible': 'bool',
                                                      'parent': 'MObject',
                                                      'wantTransform': 'bool'}},
                                           {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                      'type': 'bool'},
                                                        'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                   'type': 'MObject'}},
                                            'args': [('parent',
                                                      'MObject',
                                                      'in'),
                                                     ('UIvisible',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'UIvisible': True},
                                            'deprecated': False,
                                            'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                            'inArgs': ['parent',
                                                       'UIvisible'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'UIvisible': [],
                                                               'parent': ['const',
                                                                          '&']},
                                            'types': {'UIvisible': 'bool',
                                                      'parent': 'MObject'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {}},
  'MFnPointOnCurveManip': {'enums': {},
                           'invertibles': [('setParameter', 'parameter')],
                           'methods': {'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nClass name. \n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'connectToCurvePlug': [{'argInfo': {'curvePlug': {'doc': 'the curve plug',
                                                                                         'type': 'MPlug'}},
                                                               'args': [('curvePlug',
                                                                         'MPlug',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nConnect to the curve plug. The data type corresponding to the curvePlug is  MFnData::kNurbsCurve .',
                                                               'inArgs': ['curvePlug'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'curvePlug': ['&']},
                                                               'types': {'curvePlug': 'MPlug'}}],
                                       'connectToParamPlug': [{'argInfo': {'paramPlug': {'doc': 'the param plug',
                                                                                         'type': 'MPlug'}},
                                                               'args': [('paramPlug',
                                                                         'MPlug',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nConnect to the param plug. The data type corresponding to the paramPlug is a double.',
                                                               'inArgs': ['paramPlug'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'paramPlug': ['&']},
                                                               'types': {'paramPlug': 'MPlug'}}],
                                       'create': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\nCreates a new PointOnCurveManip. This function set's object is set to be the new manipulator.",
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Newly created PointOnCurveManip',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}},
                                                  {'argInfo': {'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                             'type': 'MString'},
                                                               'paramName': {'doc': 'Label for the parameter value that appears in the feedback line. ',
                                                                             'type': 'MString'}},
                                                   'args': [('manipName',
                                                             'MString',
                                                             'in'),
                                                            ('paramName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\nCreates a new PointOnCurveManip. This function set's object is set to be the new manipulator.",
                                                   'inArgs': ['manipName',
                                                              'paramName'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Newly created PointOnCurveManip.',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'manipName': ['const',
                                                                                    '&'],
                                                                      'paramName': ['const',
                                                                                    '&']},
                                                   'types': {'manipName': 'MString',
                                                             'paramName': 'MString'}}],
                                       'curveIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the index of the curve. The data type corresponding to this index is  MFnData::kNurbsCurve .',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Curve index',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                       'curvePoint': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the curve point.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The curve point',
                                                                      'qualifiers': [],
                                                                      'type': 'MPoint'},
                                                       'returnType': 'MPoint',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                       'isDrawCurveOn': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns whether or not the curve is drawn.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': ' true the curve is being drawn  false the curve is not being drawn  ',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                       'paramIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the index of the parameter of the PointOnCurveManip. The data type corresponding to this index is a double.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Parameter index',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                       'parameter': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturns the parameter.',
                                                      'inArgs': [],
                                                      'inverse': ('setParameter',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Parameter',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                       'setDrawCurve': [{'argInfo': {'state': {'doc': 'whether or not the curve should be drawn',
                                                                               'type': 'bool'}},
                                                         'args': [('state',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets whether or not the curve is drawn.',
                                                         'inArgs': ['state'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'state': []},
                                                         'types': {'state': 'bool'}}],
                                       'setParameter': [{'argInfo': {'parameter': {'doc': 'the parameter',
                                                                                   'type': 'double'}},
                                                         'args': [('parameter',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the parameter.',
                                                         'inArgs': ['parameter'],
                                                         'inverse': ('parameter',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'parameter': []},
                                                         'types': {'parameter': 'double'}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nFunction set type. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MFn',
                                                                         'Type')},
                                                 'returnType': ('MFn',
                                                                'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                           'pymelEnums': {},
                           'pymelMethods': {'parameter': 'getParameter'}},
  'MFnPointOnSurfaceManip': {'enums': {},
                             'invertibles': [('setParameters',
                                              'getParameters')],
                             'methods': {'className': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nClass name. \r\n',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'char'},
                                                        'returnType': 'char',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                         'connectToParamPlug': [{'argInfo': {'paramPlug': {'doc': 'the param plug',
                                                                                           'type': 'MPlug'}},
                                                                 'args': [('paramPlug',
                                                                           'MPlug',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nConnect to the param plug. The data type corresponding to the paramPlug is  MFnNumericData::k2Double .',
                                                                 'inArgs': ['paramPlug'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'paramPlug': ['&']},
                                                                 'types': {'paramPlug': 'MPlug'}}],
                                         'connectToSurfacePlug': [{'argInfo': {'surfacePlug': {'doc': 'the surface plug',
                                                                                               'type': 'MPlug'}},
                                                                   'args': [('surfacePlug',
                                                                             'MPlug',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nConnect to the surface plug. The data type corresponding to the surfacePlug is  MFnData::kNurbsSurface .',
                                                                   'inArgs': ['surfacePlug'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'surfacePlug': ['&']},
                                                                   'types': {'surfacePlug': 'MPlug'}}],
                                         'create': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nCreates a new PointOnSurfaceManip. This function set's object is set to be the new manipulator.",
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Newly created PointOnSurfaceManip',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}},
                                                    {'argInfo': {'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                               'type': 'MString'},
                                                                 'paramName': {'doc': 'Label for the parameter value which appears in the feedback line ',
                                                                               'type': 'MString'}},
                                                     'args': [('manipName',
                                                               'MString',
                                                               'in'),
                                                              ('paramName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nCreates a new PointOnSurfaceManip. This function set's object is set to be the new manipulator.",
                                                     'inArgs': ['manipName',
                                                                'paramName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Newly created PointOnSurfaceManip.',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'manipName': ['const',
                                                                                      '&'],
                                                                        'paramName': ['const',
                                                                                      '&']},
                                                     'types': {'manipName': 'MString',
                                                               'paramName': 'MString'}}],
                                         'getParameters': [{'argInfo': {'u': {'doc': 'u parameter ',
                                                                              'type': 'double'},
                                                                        'v': {'doc': 'v parameter',
                                                                              'type': 'double'}},
                                                            'args': [('u',
                                                                      'double',
                                                                      'out'),
                                                                     ('v',
                                                                      'double',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns the parameter.',
                                                            'inArgs': [],
                                                            'inverse': ('setParameters',
                                                                        False),
                                                            'outArgs': ['u',
                                                                        'v'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'u': ['&'],
                                                                               'v': ['&']},
                                                            'types': {'u': 'double',
                                                                      'v': 'double'}}],
                                         'isDrawSurfaceOn': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns whether or not the surface is drawn.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': ' true the surface is being drawn  false the surface is not being drawn  ',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                         'paramIndex': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the index of the parameter of the PointOnSurfaceManip. The data type corresponding to this index is  MFnNumericData::k2Double .',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Parameter index',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                         'setDrawArrows': [{'argInfo': {'state': {'doc': 'whether or not the arrows should be drawn',
                                                                                  'type': 'bool'}},
                                                            'args': [('state',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSets whether or not the arrows should be drawn.',
                                                            'inArgs': ['state'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'state': []},
                                                            'types': {'state': 'bool'}}],
                                         'setDrawSurface': [{'argInfo': {'state': {'doc': 'whether or not the surface should be drawn',
                                                                                   'type': 'bool'}},
                                                             'args': [('state',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSets whether or not the surface is drawn.',
                                                             'inArgs': ['state'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'state': []},
                                                             'types': {'state': 'bool'}}],
                                         'setParameters': [{'argInfo': {'u': {'doc': 'u parameter ',
                                                                              'type': 'double'},
                                                                        'v': {'doc': 'v parameter',
                                                                              'type': 'double'}},
                                                            'args': [('u',
                                                                      'double',
                                                                      'in'),
                                                                     ('v',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSets the u and v parameters.',
                                                            'inArgs': ['u',
                                                                       'v'],
                                                            'inverse': ('getParameters',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'u': [],
                                                                               'v': []},
                                                            'types': {'u': 'double',
                                                                      'v': 'double'}}],
                                         'surfaceIndex': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns the index of the surface. The data type corresponding to this index is  MFnData::kNurbsSurface .',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Surface index',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                         'type': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nFunction set type. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': ('MFn',
                                                                           'Type')},
                                                   'returnType': ('MFn',
                                                                  'Type'),
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                             'pymelEnums': {}},
  'MFnRadialField': {'enums': {},
                     'invertibles': [('setType', 'radialType')],
                     'methods': {'radialType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns a type that controls the way the radial field is attenuated.',
                                                 'inArgs': [],
                                                 'inverse': ('setType',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' A value representing a type of radial field attenuation.  A value of 1 uses the magnitude, attenuation, and distance settings from the field to determine the net force of the radial field.  A value of 0 will use the ratio of the absolute distance and the maximum distance setting.  A value between 0 and 1 will create a linear blend between the two types.  ',
                                                                'qualifiers': [],
                                                                'type': 'double'},
                                                 'returnType': 'double',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                 'setType': [{'argInfo': {'value': {'doc': 'A value representing a type of radial field attenuation.  A value of 1 uses the magnitude, attenuation, and distance settings from the field to determine the net force of the radial field.  A value of 0 will use the ratio of the absolute distance and the maximum distance setting.  A value between 0 and 1 will create a linear blend between the two types.  ',
                                                                    'type': 'double'}},
                                              'args': [('value',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSets a radial field type that controls the way the field is attenuated.',
                                              'inArgs': ['value'],
                                              'inverse': ('radialType',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'value': []},
                                              'types': {'value': 'double'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'inverse': None,
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'type': 'getType'}},
  'MFnReference': {'enums': {},
                   'invertibles': [('setIgnoreReferenceEdits',
                                    'ignoreReferenceEdits')],
                   'methods': {'associatedNamespace': [{'argInfo': {'baseName': {'doc': 'If true, return the base name of the reference ',
                                                                                 'type': 'bool'}},
                                                        'args': [('baseName',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturns the namespace associated with this reference.',
                                                        'inArgs': ['baseName'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The namespace of this reference',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'baseName': []},
                                                        'types': {'baseName': 'bool'}}],
                               'containsNode': [{'argInfo': {'node': {'doc': 'The node to be checked ',
                                                                      'type': 'MObject'}},
                                                 'args': [('node',
                                                           'MObject',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns true if the specified node is from this reference or one of its child references. The containsNodeExactly method can be used to test membership without including the child references.',
                                                 'inArgs': ['node'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Whether or not the node is from the reference or one of its child references.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'node': ['const',
                                                                             '&']},
                                                 'types': {'node': 'MObject'}}],
                               'containsNodeExactly': [{'argInfo': {'node': {'doc': 'The node to be checked ',
                                                                             'type': 'MObject'}},
                                                        'args': [('node',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturns true if the specified node is from this reference. Membership in child references is not checked. The containsNode method may be used to test membership in a reference and its child references.',
                                                        'inArgs': ['node'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Whether or not the node is from the reference.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'node': ['const',
                                                                                    '&']},
                                                        'types': {'node': 'MObject'}}],
                               'fileName': [{'argInfo': {'includeCopyNumber': {'doc': 'If true, include the copy number (if there is one) in the return string. ',
                                                                               'type': 'bool'},
                                                         'includePath': {'doc': 'If true, include the file path in the return string. ',
                                                                         'type': 'bool'},
                                                         'resolvedName': {'doc': 'If true, return the resolved name rather than the original file name. The unresolved name is the string originally specified when the file was loaded into Maya; this may contain environment variables, may be a relative path, and may otherwise not precisely indicate where the file can be located on disk. The resolved name is the actual path name that Maya is using to locate the file after relative paths and environment variables have been expanded, and any other necessary steps have been used to resolve its physical location. ',
                                                                          'type': 'bool'}},
                                             'args': [('resolvedName',
                                                       'bool',
                                                       'in'),
                                                      ('includePath',
                                                       'bool',
                                                       'in'),
                                                      ('includeCopyNumber',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of file associated with this reference.',
                                             'inArgs': ['resolvedName',
                                                        'includePath',
                                                        'includeCopyNumber'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The name of the referenced file',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'includeCopyNumber': [],
                                                                'includePath': [],
                                                                'resolvedName': []},
                                             'types': {'includeCopyNumber': 'bool',
                                                       'includePath': 'bool',
                                                       'resolvedName': 'bool'}}],
                               'ignoreReferenceEdits': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nIndicates whether reference edits will be tracked and logged or not.',
                                                         'inArgs': [],
                                                         'inverse': ('setIgnoreReferenceEdits',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                               'isExportEditsFile': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturns true if the reference is an export edits file. An export edits file is a file of type ".editMA" or ".editMB" which was created using Maya\'s offline file functionality.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Whether or not the reference is an export edits file',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                               'isLoaded': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns true if the reference is loaded.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Whether or not the reference is loaded',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'isLocked': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns true if the reference is locked or if the referenced file was saved as locked.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Returns true if the reference is locked or if the referenced file was saved as locked',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'nodes': [{'argInfo': {'nodeList': {'doc': 'the nodes from this reference ',
                                                                   'type': 'MObjectArray'}},
                                          'args': [('nodeList',
                                                    'MObjectArray',
                                                    'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns an array of the nodes associated with this reference.',
                                          'inArgs': [],
                                          'outArgs': ['nodeList'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'nodeList': ['&']},
                                          'types': {'nodeList': 'MObjectArray'}}],
                               'parentAssembly': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the parent assembly node that contains this reference. See  MFnAssembly  documentation for more details.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The parent assembly node that contains this reference or MObject::kNullObj if there is no parent assembly node.',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                               'parentFileName': [{'argInfo': {'includeCopyNumber': {'doc': 'If true, include the copy number (if there is one) in the return string. ',
                                                                                     'type': 'bool'},
                                                               'includePath': {'doc': 'If true, include the file path in the return string. ',
                                                                               'type': 'bool'},
                                                               'resolveName': {'doc': 'If true, return the resolved name rather than the original file name. The unresolved name is the string originally specified when the file was loaded into Maya; this may contain environment variables, may be a relative path, and may otherwise not precisely indicate where the file can be located on disk. The resolved name is the actual path name that Maya is using to locate the file after relative paths and environment variables have been expanded, and any other necessary steps have been used to resolve its physical location. ',
                                                                               'type': 'bool'}},
                                                   'args': [('resolveName',
                                                             'bool',
                                                             'in'),
                                                            ('includePath',
                                                             'bool',
                                                             'in'),
                                                            ('includeCopyNumber',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of parent file associated with this reference.',
                                                   'inArgs': ['resolveName',
                                                              'includePath',
                                                              'includeCopyNumber'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The name of the parent file to the reference. Returns an empty string if there is no parent file.',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'includeCopyNumber': [],
                                                                      'includePath': [],
                                                                      'resolveName': []},
                                                   'types': {'includeCopyNumber': 'bool',
                                                             'includePath': 'bool',
                                                             'resolveName': 'bool'}}],
                               'parentReference': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the reference node associated with the parent reference.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The parent reference of this reference or MObject::kNullObj if there is no associated reference.',
                                                                   'qualifiers': [],
                                                                   'type': 'MObject'},
                                                    'returnType': 'MObject',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                               'setIgnoreReferenceEdits': [{'argInfo': {'ignoreEdits': {'doc': 'If true reference edits will not be logged. ',
                                                                                        'type': 'bool'}},
                                                            'args': [('ignoreEdits',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSpecify whether reference edits should be tracked and logged or not. This should be treated as a temporary state and should be enabled around a batch of operations where reference edits should be ignored. Restore the previous value when the batch of operations is complete.',
                                                            'inArgs': ['ignoreEdits'],
                                                            'inverse': ('ignoreReferenceEdits',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': True,
                                                            'typeQualifiers': {'ignoreEdits': []},
                                                            'types': {'ignoreEdits': 'bool'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nFunction set type. \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'ignoreReferenceEdits': 'getIgnoreReferenceEdits'}},
  'MFnReflectShader': {'enums': {},
                       'invertibles': [('setReflectedColor',
                                        'reflectedColor'),
                                       ('setSpecularColor',
                                        'specularColor'),
                                       ('setReflectedRayDepthLimit',
                                        'reflectedRayDepthLimit'),
                                       ('setReflectivity', 'reflectivity')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nClass name. \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'reflectedColor': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nRetrieves the value of the "reflectedColor" attribute of a reflective shader node. This attribute represents the color of reflection produced by the shader.',
                                                       'inArgs': [],
                                                       'inverse': ('setReflectedColor',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The value of the "reflectedColor" attribute of the shader node.',
                                                                      'qualifiers': [],
                                                                      'type': 'MColor'},
                                                       'returnType': 'MColor',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                   'reflectedRayDepthLimit': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nRetrieves the value of the "reflectedRayDepthLimit" attribute of a reflective shader node. This attribute represents the maximum reflected ray depth used in the shading calculation.',
                                                               'inArgs': [],
                                                               'inverse': ('setReflectedRayDepthLimit',
                                                                           False),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The value of the "reflectedRayDepthLimit" attribute of the node.',
                                                                              'qualifiers': [],
                                                                              'type': 'short'},
                                                               'returnType': 'short',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                                               'types': {}}],
                                   'reflectivity': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the value of the "reflectivity" attribute of a reflective shader node. This attribute represents the reflectivity of the shader.',
                                                     'inArgs': [],
                                                     'inverse': ('setReflectivity',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "reflectivity" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                   'setReflectedColor': [{'argInfo': {'reflected_color': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'MColor'}},
                                                          'args': [('reflected_color',
                                                                    'MColor',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the value of the "reflectedColor" attribute of a shader node.',
                                                          'inArgs': ['reflected_color'],
                                                          'inverse': ('reflectedColor',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'reflected_color': ['const',
                                                                                                 '&']},
                                                          'types': {'reflected_color': 'MColor'}}],
                                   'setReflectedRayDepthLimit': [{'argInfo': {'reflected_ray_depth_limit': {'doc': 'value to which the attribute will be set.',
                                                                                                            'type': 'short'}},
                                                                  'args': [('reflected_ray_depth_limit',
                                                                            'short',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nSets the value of the "reflectedRayDepthLimit" attribute of a lambert shader node.',
                                                                  'inArgs': ['reflected_ray_depth_limit'],
                                                                  'inverse': ('reflectedRayDepthLimit',
                                                                              True),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'reflected_ray_depth_limit': ['const',
                                                                                                                   '&']},
                                                                  'types': {'reflected_ray_depth_limit': 'short'}}],
                                   'setReflectivity': [{'argInfo': {'reflect': {'doc': 'value to which the attribute will be set.',
                                                                                'type': 'float'}},
                                                        'args': [('reflect',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the value of the "reflectivity" attribute of a shader node.',
                                                        'inArgs': ['reflect'],
                                                        'inverse': ('reflectivity',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'reflect': ['const',
                                                                                       '&']},
                                                        'types': {'reflect': 'float'}}],
                                   'setSpecularColor': [{'argInfo': {'specular_color': {'doc': 'value to which the attribute will be set.',
                                                                                        'type': 'MColor'}},
                                                         'args': [('specular_color',
                                                                   'MColor',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the value of the "specularColor" attribute of a shader node.',
                                                         'inArgs': ['specular_color'],
                                                         'inverse': ('specularColor',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'specular_color': ['const',
                                                                                               '&']},
                                                         'types': {'specular_color': 'MColor'}}],
                                   'specularColor': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nRetrieves the value of the "specularColor" attribute of a reflective shader node. This attribute represents the color of specular highlights produced by the shader.',
                                                      'inArgs': [],
                                                      'inverse': ('setSpecularColor',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The value of the "specularColor" attribute of the shader node.',
                                                                     'qualifiers': [],
                                                                     'type': 'MColor'},
                                                      'returnType': 'MColor',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nFunction set type. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}]},
                       'pymelEnums': {},
                       'pymelMethods': {'reflectedColor': 'getReflectedColor',
                                        'reflectedRayDepthLimit': 'getReflectedRayDepthLimit',
                                        'reflectivity': 'getReflectivity',
                                        'specularColor': 'getSpecularColor'}},
  'MFnRenderLayer': {'enums': {},
                     'methods': {'adjustmentPlug': [{'argInfo': {'scenePlug': {'doc': 'The plug for which the adjustment is sought. ',
                                                                               'type': 'MPlug'}},
                                                     'args': [('scenePlug',
                                                               'MPlug',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturns the render layer adjustment value plug for the specified plug. If there is no layer override on the plug, a copy of scenePlug is returned.',
                                                     'inArgs': ['scenePlug'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The render layer adjustment plug.',
                                                                    'qualifiers': [],
                                                                    'type': 'MPlug'},
                                                     'returnType': 'MPlug',
                                                     'static': False,
                                                     'typeQualifiers': {'retStatus': ['*'],
                                                                        'scenePlug': ['const',
                                                                                      '&']},
                                                     'types': {'scenePlug': 'MPlug'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nClass name. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'currentLayer': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the  MObject  for the current render layer. This  MObject  can be used in  MFnRenderLayer .',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The current render layer.',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                 'defaultRenderLayer': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the  MObject  for the defaultRenderLayer. This  MObject  can be used in  MFnRenderLayer .',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The default render layer.',
                                                                        'qualifiers': [],
                                                                        'type': 'MObject'},
                                                         'returnType': 'MObject',
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                 'externalRenderPasses': [{'argInfo': {'renderPassArray': {'doc': 'Array to which the result of the search is written.',
                                                                                           'type': 'MObjectArray'}},
                                                           'args': [(u'renderPassArray',
                                                                     'MObjectArray',
                                                                     u'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nThe function builds an array of unique render pass nodes ( MObject ) that are connected to the renderPass attribute. This function descends recursively into render pass sets to collect all connected render passes.',
                                                           'inArgs': [],
                                                           'outArgs': [u'renderPassArray'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'renderPassArray': ['&']},
                                                           'types': {'renderPassArray': 'MObjectArray'}}],
                                 'findLayerByName': [{'argInfo': {'renderLayer': {'doc': 'The name of the render layer. ',
                                                                                  'type': 'MString'}},
                                                      'args': [('renderLayer',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nThis function returns an  MObject  to a render layer that matches the specified name. If no render layer is found with the given name,  MObject::kNullObj  is returned.',
                                                      'inArgs': ['renderLayer'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The matching render layer or MObject::kNullObj if no matching render layer was found.',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'renderLayer': ['const',
                                                                                         '&']},
                                                      'types': {'renderLayer': 'MString'}}],
                                 'inCurrentRenderLayer': [{'argInfo': {'objectPath': {'doc': 'Path of the render layer object. ',
                                                                                      'type': 'MDagPath'}},
                                                           'args': [('objectPath',
                                                                     'MDagPath',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nThe function checks if the given object is present in the current render layer or not.',
                                                           'inArgs': ['objectPath'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'True if the given object is in the current render layer, false otherwise.',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'objectPath': ['const',
                                                                                             '&']},
                                                           'types': {'objectPath': 'MDagPath'}}],
                                 'inLayer': [{'argInfo': {'transform': {'doc': 'MObject of the shape we are testing against. ',
                                                                        'type': 'MObject'}},
                                              'args': [('transform',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns true if the given shape is in this layer. This method will check all container layers for transform containment. The  MObject  specified must be a shape node.',
                                              'inArgs': ['transform'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'True if the given node is in the layer, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'transform': ['const',
                                                                               '&']},
                                              'types': {'transform': 'MObject'}}],
                                 'isPlugAdjusted': [{'argInfo': {'scenePlug': {'doc': 'The plug which needs to be checked for adjustment. ',
                                                                               'type': 'MPlug'}},
                                                     'args': [('scenePlug',
                                                               'MPlug',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nThe function checks if the specified plug is adjusted or not; returns true if the plug is adjusted, else returns false.',
                                                     'inArgs': ['scenePlug'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'True if the plug is adjusted, false otherwise.',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'retStatus': ['*'],
                                                                        'scenePlug': ['const',
                                                                                      '&']},
                                                     'types': {'scenePlug': 'MPlug'}}],
                                 'layerChildren': [{'argInfo': {'array': {'doc': 'List of contained render layers. ',
                                                                          'type': 'MObjectArray'},
                                                                'recurse': {'doc': 'If true then the list operation will be applied recursively to any contained render layers which themselves contain other render layers.',
                                                                            'type': 'bool'}},
                                                    'args': [(u'array',
                                                              'MObjectArray',
                                                              u'out'),
                                                             (u'recurse',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {'recurse': False},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the container layers for this layer. Container layers provide the ability for a given render layer to "contain" other render layers.',
                                                    'inArgs': [u'recurse'],
                                                    'outArgs': [u'array'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'array': ['&'],
                                                                       'recurse': []},
                                                    'types': {'array': 'MObjectArray',
                                                              'recurse': 'bool'}}],
                                 'listAllRenderLayers': [{'argInfo': {'array': {'doc': 'MObjectArray of render layers.',
                                                                                'type': 'MObjectArray'}},
                                                          'args': [(u'array',
                                                                    'MObjectArray',
                                                                    u'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the list of render layers currently in the system.',
                                                          'inArgs': [],
                                                          'outArgs': [u'array'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': True,
                                                          'typeQualifiers': {'array': ['&']},
                                                          'types': {'array': 'MObjectArray'}}],
                                 'listMembers': [{'argInfo': {'objectsInLayer': {'doc': 'The array of MObjects, present in the layer.',
                                                                                 'type': 'MObjectArray'}},
                                                  'args': [(u'objectsInLayer',
                                                            'MObjectArray',
                                                            u'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the objects present in the render layer.',
                                                  'inArgs': [],
                                                  'outArgs': [u'objectsInLayer'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'objectsInLayer': ['&']},
                                                  'types': {'objectsInLayer': 'MObjectArray'}}],
                                 'passHasLight': [{'argInfo': {'light': {'doc': 'a light shape node ',
                                                                         'type': 'MObject'},
                                                               'renderPass': {'doc': 'a render pass node ',
                                                                              'type': 'MObject'}},
                                                   'args': [('renderPass',
                                                             'MObject',
                                                             'in'),
                                                            ('light',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns true if the specified light contributes to the given render pass, based on the pass contribution maps attached to this layer. This method does not verify whether the light or the renderPass are actually rendered by the layer.',
                                                   'inArgs': ['renderPass',
                                                              'light'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if the light contributes to the pass, false otherwise.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'light': ['const',
                                                                                '&'],
                                                                      'renderPass': ['const',
                                                                                     '&']},
                                                   'types': {'light': 'MObject',
                                                             'renderPass': 'MObject'}}],
                                 'passHasObject': [{'argInfo': {'objectInstance': {'doc': 'DAG path of a shape instance ',
                                                                                   'type': 'MDagPath'},
                                                                'renderPass': {'doc': 'a render pass node ',
                                                                               'type': 'MObject'}},
                                                    'args': [('renderPass',
                                                              'MObject',
                                                              'in'),
                                                             ('objectInstance',
                                                              'MDagPath',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns true if the specified object instance contributes to the given render pass, based on the pass contribution maps attached to the layer. This method does not verify whether the object instance or the renderPass are actually rendered by the layer.',
                                                    'inArgs': ['renderPass',
                                                               'objectInstance'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True if the object contributes to the pass, false otherwise.',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'objectInstance': ['const',
                                                                                          '&'],
                                                                       'renderPass': ['const',
                                                                                      '&']},
                                                    'types': {'objectInstance': 'MDagPath',
                                                              'renderPass': 'MObject'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnRenderPass': {'enums': {},
                    'invertibles': [('setImplementation',
                                     'getImplementation')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nClass name. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'customTokenString': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns a custom token string that can be passed to  MCommonRenderSettingsData::getImageName()  to generate a file name for the pass.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                'frameBufferChannels': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the number of channels of the frame buffer associated with the render pass.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                'frameBufferType': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturns the data type of the frame buffer associated with the render pass.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': ('MPxRenderPassImpl',
                                                                             'PassTypeBit')},
                                                     'returnType': ('MPxRenderPassImpl',
                                                                    'PassTypeBit'),
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                'getImplementation': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the render pass implementation that was resolved by the previous call to setImplementation. \n',
                                                       'inArgs': [],
                                                       'inverse': ('setImplementation',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'MPxRenderPassImpl'},
                                                       'returnType': 'MPxRenderPassImpl',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                'passID': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns the passID string that uniquely identifies the renderpass definition associated with the pass',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'setImplementation': [{'argInfo': {'renderer': {'doc': 'string that identifies the the render and its version. The format of this string is specified by renderer plug-in. ',
                                                                                'type': 'MString'}},
                                                       'args': [('renderer',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the first render pass implementation compatible with the specified renderer and that supports the currently selected frame buffer data type and the selected number of channels.',
                                                       'inArgs': ['renderer'],
                                                       'inverse': ('getImplementation',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A pointer to the render implementation object.',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'MPxRenderPassImpl'},
                                                       'returnType': 'MPxRenderPassImpl',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'renderer': ['const',
                                                                                       '&']},
                                                       'types': {'renderer': 'MString'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nFunction set type. \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'usesFiltering': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns true if frame buffer filtering is requested. This setting may be ignored in the cases of frame buffer types and frame buffer semantics that do not allow interpolation.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}]},
                    'pymelEnums': {}},
  'MFnRotateManip': {'enums': {'RotateMode': {'valueDocs': {'gimbal': 'Gimbal.',
                                                            'kGimbal': 'Gimbal.',
                                                            'kObjectSpace': 'Object Space (default).',
                                                            'kWorldSpace': 'World Space.',
                                                            'objectSpace': 'Object Space (default).',
                                                            'worldSpace': 'World Space.'},
                                              'values': "Enum('RotateMode', {'kObjectSpace': 0, 'kWorldSpace': 1, 'kGimbal': 2})"}},
                     'invertibles': [('setSnapIncrement', 'snapIncrement'),
                                     ('setRotateMode', 'rotateMode')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClass name. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'connectToRotationCenterPlug': [{'argInfo': {'rotationCenterPlug': {'doc': 'The plug to connect the rotation center to',
                                                                                                     'type': 'MPlug'}},
                                                                  'args': [('rotationCenterPlug',
                                                                            'MPlug',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nCreate a 1-1 association of the rotation center on the manipulator and the rotationCenterPlug parameter. When both the rotation center is attached to a plug and the  displayWithNode()  method has been called, the manipulator will display with the node regardless of the connection made to the rotation center.',
                                                                  'inArgs': ['rotationCenterPlug'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'rotationCenterPlug': ['const',
                                                                                                            '&']},
                                                                  'types': {'rotationCenterPlug': 'MPlug'}}],
                                 'connectToRotationPlug': [{'argInfo': {'rotationPlug': {'doc': 'The plug to connect the rotation value to',
                                                                                         'type': 'MPlug'}},
                                                            'args': [('rotationPlug',
                                                                      'MPlug',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nCreate a 1-1 connection from the rotation manipVal to the rotationPlug parameter. Any changes to the rotation manipVal will be immediately reflected in the connected plug. Connecting to the "rotation" plug on a transform node will produce similar behavior to the built-in rotate manipulator.',
                                                            'inArgs': ['rotationPlug'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'rotationPlug': ['const',
                                                                                                '&']},
                                                            'types': {'rotationPlug': 'MPlug'}}],
                                 'create': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCreates a new RotateManip, and attaches this function set to the new manipulator.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'An object corresponding to the new manipulator',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}},
                                            {'argInfo': {'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                       'type': 'MString'},
                                                         'rotationName': {'doc': 'Label for the rotation value displayed in the feedback line. ',
                                                                          'type': 'MString'}},
                                             'args': [('manipName',
                                                       'MString',
                                                       'in'),
                                                      ('rotationName',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCreates a new RotateManip, and attaches this function set to the new manipulator.',
                                             'inArgs': ['manipName',
                                                        'rotationName'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'An object corresponding to the new manipulator.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'manipName': ['const',
                                                                              '&'],
                                                                'rotationName': ['const',
                                                                                 '&']},
                                             'types': {'manipName': 'MString',
                                                       'rotationName': 'MString'}}],
                                 'displayWithNode': [{'argInfo': {'node': {'doc': 'The node the manipulator should display with',
                                                                           'type': 'MObject'}},
                                                      'args': [('node',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nConfigures the manipulator to display with the node, causing the position of the manipulator to follow the position of the node whenever the node is moved. The node must be a DAG object.',
                                                      'inArgs': ['node'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'node': ['const',
                                                                                  '&']},
                                                      'types': {'node': 'MObject'}}],
                                 'isSnapModeOn': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns true when snap mode is on.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'rotateMode': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the current rotation mode.',
                                                 'inArgs': [],
                                                 'inverse': ('setRotateMode',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MFnRotateManip',
                                                                         'RotateMode')},
                                                 'returnType': ('MFnRotateManip',
                                                                'RotateMode'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                 'rotationCenterIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns the index of the rotation center for the manipulator.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Rotation center index',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                 'rotationIndex': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the index of the rotation manipVal for the manipulator. When plugToManip conversion functions are used to produce the rotation manipVal, the manipulator data must be of the type  MFnNumericData::k3Double , with X,Y, and Z rotations given in radians. This is easily accomplished by using the  MEulerRotation  class to manage the rotations.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Rotation index',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                 'setInitialRotation': [{'argInfo': {'rotation': {'doc': 'The initial rotation',
                                                                                  'type': 'MEulerRotation'}},
                                                         'args': [('rotation',
                                                                   'MEulerRotation',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the initial rotation for the rotate manipulator. Setting the initial rotation will prevent the manipulator from jumping back to the default rotation when there is already an existing rotation on the target plug.',
                                                         'inArgs': ['rotation'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'rotation': ['const',
                                                                                         '&']},
                                                         'types': {'rotation': 'MEulerRotation'}}],
                                 'setRotateMode': [{'argInfo': {'mode': {'doc': 'The new manipulator mode',
                                                                         'type': ('MFnRotateManip',
                                                                                  'RotateMode')}},
                                                    'args': [('mode',
                                                              ('MFnRotateManip',
                                                               'RotateMode'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the mode for the rotation manipulator. The manipulator mode controls the appearance of the manipulator when is it used.',
                                                    'inArgs': ['mode'],
                                                    'inverse': ('rotateMode',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'mode': []},
                                                    'types': {'mode': ('MFnRotateManip',
                                                                       'RotateMode')}}],
                                 'setRotationCenter': [{'argInfo': {'rotationCenter': {'doc': 'The world space position of the rotation center.',
                                                                                       'type': 'MPoint'}},
                                                        'args': [('rotationCenter',
                                                                  'MPoint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the position of the rotation center for the manipulator.',
                                                        'inArgs': ['rotationCenter'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'rotationCenter': ['const',
                                                                                              '&']},
                                                        'types': {'rotationCenter': 'MPoint'}}],
                                 'setSnapIncrement': [{'argInfo': {'snapInc': {'doc': 'The new snap increment in degrees',
                                                                               'type': 'double'}},
                                                       'args': [('snapInc',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the snap increment. The snap increment is specified in degrees. Manipulator values will snap to the next rotation at an angle of snapInc from the original rotation. Note that snap rotate does not apply to the trackball rotations (when dragging between the rotate discs).',
                                                       'inArgs': ['snapInc'],
                                                       'inverse': ('snapIncrement',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'snapInc': []},
                                                       'types': {'snapInc': 'double'}}],
                                 'setSnapMode': [{'argInfo': {'snapEnabled': {'doc': 'The new snap mode',
                                                                              'type': 'bool'}},
                                                  'args': [('snapEnabled',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets the snap mode. The snap modes can be either on (true) or off (false). When snap mode is on, rotation manip values will snap to the values within some increment apart.',
                                                  'inArgs': ['snapEnabled'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'snapEnabled': []},
                                                  'types': {'snapEnabled': 'bool'}}],
                                 'snapIncrement': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the snapping increment in degrees.',
                                                    'inArgs': [],
                                                    'inverse': ('setSnapIncrement',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'double'},
                                                    'returnType': 'double',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {'RotateMode': "Enum('RotateMode', [('objectSpace', 0), ('kObjectSpace', 0), ('worldSpace', 1), ('kWorldSpace', 1), ('gimbal', 2), ('kGimbal', 2)], multiKeys=True)"},
                     'pymelMethods': {'rotateMode': 'getRotateMode',
                                      'snapIncrement': 'getSnapIncrement'}},
  'MFnScaleManip': {'enums': {},
                    'invertibles': [('setOrientation', 'getOrientation'),
                                    ('setOrientationMode',
                                     'getOrientationMode'),
                                    ('setSnapIncrement', 'snapIncrement')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'connectToScaleCenterPlug': [{'argInfo': {'scaleCenterPlug': {'doc': 'The plug to connect the scale center to',
                                                                                              'type': 'MPlug'}},
                                                              'args': [('scaleCenterPlug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nCreate a 1-1 association of the scale center on the manipulator and the scaleCenterPlug parameter. When both the scale center is attached to a plug and the  displayWithNode()  method has been called, the manipulator will display with the node regardless of the connection made to the scale center.',
                                                              'inArgs': ['scaleCenterPlug'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'scaleCenterPlug': ['const',
                                                                                                     '&']},
                                                              'types': {'scaleCenterPlug': 'MPlug'}}],
                                'connectToScalePlug': [{'argInfo': {'scalePlug': {'doc': 'The plug to connect the scale value to',
                                                                                  'type': 'MPlug'}},
                                                        'args': [('scalePlug',
                                                                  'MPlug',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nCreate a 1-1 connection from the scale manipVal to the scalePlug parameter. Any changes to the scale manipVal will be immediately reflected in the connected plug. Connecting to the "scale" plug on a transform node will produce similar behavior to the built-in scale manipulator.',
                                                        'inArgs': ['scalePlug'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'scalePlug': ['const',
                                                                                         '&']},
                                                        'types': {'scalePlug': 'MPlug'}}],
                                'create': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreates a new ScaleManip, and attaches this function set to the new manipulator.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'An object corresponding to the new manipulator',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}},
                                           {'argInfo': {'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                      'type': 'MString'},
                                                        'scaleName': {'doc': 'Label for the scale value displayed in the feedback line. ',
                                                                      'type': 'MString'}},
                                            'args': [('manipName',
                                                      'MString',
                                                      'in'),
                                                     ('scaleName',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreates a new ScaleManip, and attaches this function set to the new manipulator.',
                                            'inArgs': ['manipName',
                                                       'scaleName'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'An object corresponding to the new manipulator.',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'manipName': ['const',
                                                                             '&'],
                                                               'scaleName': ['const',
                                                                             '&']},
                                            'types': {'manipName': 'MString',
                                                      'scaleName': 'MString'}}],
                                'displayWithNode': [{'argInfo': {'node': {'doc': 'The node the manipulator should display with',
                                                                          'type': 'MObject'}},
                                                     'args': [('node',
                                                               'MObject',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nConfigures the manipulator to display with the node, causing the position of the manipulator to follow the position of the node whenever the node is moved. The node must be a DAG object.',
                                                     'inArgs': ['node'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'node': ['const',
                                                                                 '&']},
                                                     'types': {'node': 'MObject'}}],
                                'getOrientation': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the orientation used by the manip when its orientationMode is set to kArbitraryOrientation.',
                                                    'inArgs': [],
                                                    'inverse': ('setOrientation',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Current orientation direction of the manip',
                                                                   'qualifiers': [],
                                                                   'type': 'MEulerRotation'},
                                                    'returnType': 'MEulerRotation',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                'getOrientationMode': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGets the orientation mode of the  MFnScaleManip .',
                                                        'inArgs': [],
                                                        'inverse': ('setOrientationMode',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'current orientation mode of the manip',
                                                                       'qualifiers': [],
                                                                       'type': ('MFnScaleManip',
                                                                                'ScaleOrientationMode')},
                                                        'returnType': ('MFnScaleManip',
                                                                       'ScaleOrientationMode'),
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                'isSnapModeOn': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns true when snap mode is on.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                'scaleCenterIndex': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the index of the scale center manipVal for this manipulator.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Scale center index',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                'scaleIndex': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the index of the scale manipVal for this manipulator.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Scale index',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'setInitialScale': [{'argInfo': {'scale': {'doc': 'The initial scale',
                                                                           'type': 'MVector'}},
                                                     'args': [('scale',
                                                               'MVector',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the initial scale for the scale manipulator. Setting the initial scale will prevent the manipulator from jumping back to the default scale when there is already an existing scale on the target plug.',
                                                     'inArgs': ['scale'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'scale': ['const',
                                                                                  '&']},
                                                     'types': {'scale': 'MVector'}}],
                                'setOrientation': [{'argInfo': {'orientation': {'doc': 'the new orientation for MFnScaleManip.',
                                                                                'type': 'MEulerRotation'}},
                                                    'args': [('orientation',
                                                              'MEulerRotation',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the arbitrary orientation of the  MFnScaleManip . This only has any effect when the orientation mode is set to kArbitraryOrientation',
                                                    'inArgs': ['orientation'],
                                                    'inverse': ('getOrientation',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'orientation': ['const',
                                                                                       '&']},
                                                    'types': {'orientation': 'MEulerRotation'}}],
                                'setOrientationMode': [{'argInfo': {'mode': {'doc': 'the new orientation mode of the MFnScaleManip.',
                                                                             'type': ('MFnScaleManip',
                                                                                      'ScaleOrientationMode')}},
                                                        'args': [('mode',
                                                                  ('MFnScaleManip',
                                                                   'ScaleOrientationMode'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the orientation mode of the  MFnScaleManip .',
                                                        'inArgs': ['mode'],
                                                        'inverse': ('getOrientationMode',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'mode': []},
                                                        'types': {'mode': ('MFnScaleManip',
                                                                           'ScaleOrientationMode')}}],
                                'setSnapIncrement': [{'argInfo': {'snapInc': {'doc': 'The new snap increment',
                                                                              'type': 'double'}},
                                                      'args': [('snapInc',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the snap increment. The snap increment is specified in the working unit, and is the distance between snap points when dragging the scale handles.',
                                                      'inArgs': ['snapInc'],
                                                      'inverse': ('snapIncrement',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'snapInc': []},
                                                      'types': {'snapInc': 'double'}}],
                                'setSnapMode': [{'argInfo': {'snapEnabled': {'doc': 'The new snap mode',
                                                                             'type': 'bool'}},
                                                 'args': [('snapEnabled',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the snap mode. The snap modes can be either on (true) or off (false). When snap mode is on, scale values will snap to scale value within some interval apart. The interval is set using  setSnapIncrement() .',
                                                 'inArgs': ['snapEnabled'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'snapEnabled': []},
                                                 'types': {'snapEnabled': 'bool'}}],
                                'snapIncrement': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the snapping increment in working units.',
                                                   'inArgs': [],
                                                   'inverse': ('setSnapIncrement',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'double'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'snapIncrement': 'getSnapIncrement'}},
  'MFnSet': {'enums': {'Restriction': {'valueDocs': {'edgesOnly': '',
                                                     'editPointsOnly': '',
                                                     'facetsOnly': '',
                                                     'kEdgesOnly': '',
                                                     'kEditPointsOnly': '',
                                                     'kFacetsOnly': '',
                                                     'kNone': '',
                                                     'kRenderableOnly': '',
                                                     'kVerticesOnly': '',
                                                     'none': '',
                                                     'renderableOnly': '',
                                                     'verticesOnly': ''},
                                       'values': "Enum('Restriction', {'kNone': 0, 'kVerticesOnly': 1, 'kEdgesOnly': 2, 'kFacetsOnly': 3, 'kEditPointsOnly': 4, 'kRenderableOnly': 5})"}},
             'invertibles': [('setAnnotation', 'annotation')],
             'methods': {'addMember': [{'argInfo': {'obj': {'doc': 'the object to add',
                                                            'type': 'MObject'}},
                                        'args': [('obj',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nAdd a new object (dependency node) to the set.',
                                        'inArgs': ['obj'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'obj': ['const',
                                                                   '&']},
                                        'types': {'obj': 'MObject'}},
                                       {'argInfo': {'component': {'doc': 'the selection component',
                                                                  'type': 'MObject'},
                                                    'obj': {'doc': 'the object to add ',
                                                            'type': 'MDagPath'}},
                                        'args': [('obj',
                                                  'MDagPath',
                                                  'in'),
                                                 ('component',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {'component': 'MObject::kNullObj'},
                                        'deprecated': False,
                                        'doc': '\r\nAdd a new object (DAG node) to the set.',
                                        'inArgs': ['obj', 'component'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'component': ['const',
                                                                         '&'],
                                                           'obj': ['const',
                                                                   '&']},
                                        'types': {'component': 'MObject',
                                                  'obj': 'MDagPath'}},
                                       {'argInfo': {'plug': {'doc': 'the plug to add',
                                                             'type': 'MPlug'}},
                                        'args': [('plug', 'MPlug', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nAdd a new plug to the set.',
                                        'inArgs': ['plug'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'plug': ['const',
                                                                    '&']},
                                        'types': {'plug': 'MPlug'}}],
                         'addMembers': [{'argInfo': {'list': {'doc': 'the list of objects as a selection list',
                                                              'type': 'MSelectionList'}},
                                         'args': [('list',
                                                   'MSelectionList',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nAdd a list of new objects to the set.',
                                         'inArgs': ['list'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'list': ['const',
                                                                     '&']},
                                         'types': {'list': 'MSelectionList'}}],
                         'annotation': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the annotation string for this set. This allows a description of the set to be stored with it.',
                                         'inArgs': [],
                                         'inverse': ('setAnnotation',
                                                     False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The annotation string',
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                         'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nClass name. \r\n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['*'],
                                                       'type': 'char'},
                                        'returnType': 'char',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'clear': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nRemoves all elements from this set',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                         'create': [{'argInfo': {'members': {'doc': 'list of members for new set ',
                                                             'type': 'MSelectionList'},
                                                 'restriction': {'doc': 'restriction applied to members ',
                                                                 'type': ('MFnSet',
                                                                          'Restriction')}},
                                     'args': [('members',
                                               'MSelectionList',
                                               'in'),
                                              ('restriction',
                                               ('MFnSet',
                                                'Restriction'),
                                               'in')],
                                     'defaults': {'restriction': ('MFnSet',
                                                                  'Restriction',
                                                                  'kNone')},
                                     'deprecated': False,
                                     'doc': '\r\nCreates a new set dependency node and puts it in the dependency graph.',
                                     'inArgs': ['members', 'restriction'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'A handle for the new set object',
                                                    'qualifiers': [],
                                                    'type': 'MObject'},
                                     'returnType': 'MObject',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                        'members': ['const',
                                                                    '&'],
                                                        'restriction': []},
                                     'types': {'members': 'MSelectionList',
                                               'restriction': ('MFnSet',
                                                               'Restriction')}}],
                         'getIntersection': [{'argInfo': {'result': {'doc': 'storage for the result of the intersection operation',
                                                                     'type': 'MSelectionList'},
                                                          'withSet': {'doc': 'set to find intersection of with this set ',
                                                                      'type': 'MObject'}},
                                              'args': [('withSet',
                                                        'MObject',
                                                        'in'),
                                                       ('result',
                                                        'MSelectionList',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method calculates the intersection of two sets. The result will be the intersection of this set and the set passed into the method.',
                                              'inArgs': ['withSet'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'result': ['&'],
                                                                 'withSet': ['const',
                                                                             '&']},
                                              'types': {'result': 'MSelectionList',
                                                        'withSet': 'MObject'}},
                                             {'argInfo': {'result': {'doc': 'storage for the result of the intersection operation',
                                                                     'type': 'MSelectionList'},
                                                          'setList': {'doc': 'sets to find intersection of with this set ',
                                                                      'type': 'MObjectArray'}},
                                              'args': [('setList',
                                                        'MObjectArray',
                                                        'in'),
                                                       ('result',
                                                        'MSelectionList',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method calculates the intersection of a list of sets. The result will be the intersection of this set and the sets passed into the method.',
                                              'inArgs': ['setList'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'result': ['&'],
                                                                 'setList': ['const',
                                                                             '&']},
                                              'types': {'result': 'MSelectionList',
                                                        'setList': 'MObjectArray'}}],
                         'getMembers': [{'argInfo': {'flatten': {'doc': 'whether to flatten the returned list.',
                                                                 'type': 'bool'},
                                                     'members': {'doc': 'storage for the returned list of members ',
                                                                 'type': 'MSelectionList'}},
                                         'args': [('members',
                                                   'MSelectionList',
                                                   'out'),
                                                  ('flatten',
                                                   'bool',
                                                   'in')],
                                         'defaults': {'flatten': False},
                                         'deprecated': False,
                                         'doc': '\r\nGet the members of this set as a selection list. This information is provided as a selection list so that all of the path information is retained for DAG nodes.',
                                         'inArgs': ['flatten'],
                                         'outArgs': ['members'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'flatten': [],
                                                            'members': ['&']},
                                         'types': {'flatten': 'bool',
                                                   'members': 'MSelectionList'}}],
                         'getUnion': [{'argInfo': {'result': {'doc': 'storage for the result of the union operation',
                                                              'type': 'MSelectionList'},
                                                   'withSet': {'doc': 'set to find union of with this set ',
                                                               'type': 'MObject'}},
                                       'args': [('withSet',
                                                 'MObject',
                                                 'in'),
                                                ('result',
                                                 'MSelectionList',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThis method calculates the union of two sets. The result will be the union of this set and the set passed into the method.',
                                       'inArgs': ['withSet'],
                                       'outArgs': ['result'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'result': ['&'],
                                                          'withSet': ['const',
                                                                      '&']},
                                       'types': {'result': 'MSelectionList',
                                                 'withSet': 'MObject'}},
                                      {'argInfo': {'result': {'doc': 'storage for the result of the union operation',
                                                              'type': 'MSelectionList'},
                                                   'setList': {'doc': 'sets to find union of with this set ',
                                                               'type': 'MObjectArray'}},
                                       'args': [('setList',
                                                 'MObjectArray',
                                                 'in'),
                                                ('result',
                                                 'MSelectionList',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThis method calculates the union of a list of sets. The result will be the union of this set and the sets passed into the method.',
                                       'inArgs': ['setList'],
                                       'outArgs': ['result'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'result': ['&'],
                                                          'setList': ['const',
                                                                      '&']},
                                       'types': {'result': 'MSelectionList',
                                                 'setList': 'MObjectArray'}}],
                         'hasRestrictions': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns true if this function set has restrictions on the type of objects that it may contain.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A boolean value indicating whether this set has restriction',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                         'intersectsWith': [{'argInfo': {'otherSet': {'doc': 'set to test for intersection with ',
                                                                      'type': 'MObject'}},
                                             'args': [('otherSet',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns true if this set intersects with the given set. An intersection occurs if there are any common members between the two sets.',
                                             'inArgs': ['otherSet'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Boolean value indicating whether there was an intersection',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'otherSet': ['const',
                                                                             '&']},
                                             'types': {'otherSet': 'MObject'}}],
                         'isMember': [{'argInfo': {'object': {'doc': 'object to test for membership ',
                                                              'type': 'MObject'}},
                                       'args': [('object',
                                                 'MObject',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns true if the given object (dependency node) is a member of this set',
                                       'inArgs': ['object'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A boolean value indicating whether the object is a member',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                          'object': ['const',
                                                                     '&']},
                                       'types': {'object': 'MObject'}},
                                      {'argInfo': {'component': {'doc': 'selection component (optional) ',
                                                                 'type': 'MObject'},
                                                   'object': {'doc': 'object to test for membership ',
                                                              'type': 'MDagPath'}},
                                       'args': [('object',
                                                 'MDagPath',
                                                 'in'),
                                                ('component',
                                                 'MObject',
                                                 'in')],
                                       'defaults': {'component': 'MObject::kNullObj'},
                                       'deprecated': False,
                                       'doc': '\r\nReturns true if the given object (DAG node) is a member of this set',
                                       'inArgs': ['object', 'component'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A boolean value indicating whether the object is a member',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                          'component': ['const',
                                                                        '&'],
                                                          'object': ['const',
                                                                     '&']},
                                       'types': {'component': 'MObject',
                                                 'object': 'MDagPath'}},
                                      {'argInfo': {'plug': {'doc': 'plug to test for membership ',
                                                            'type': 'MPlug'}},
                                       'args': [('plug', 'MPlug', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns true if the given plug is a member of this set',
                                       'inArgs': ['plug'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A boolean value indicating whether the plug is a member',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                          'plug': ['const',
                                                                   '&']},
                                       'types': {'plug': 'MPlug'}}],
                         'removeMember': [{'argInfo': {'obj': {'doc': 'the object to remove',
                                                               'type': 'MObject'}},
                                           'args': [('obj',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRemove an object (dependency node) from the set.',
                                           'inArgs': ['obj'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'obj': ['const',
                                                                      '&']},
                                           'types': {'obj': 'MObject'}},
                                          {'argInfo': {'component': {'doc': 'the selection component',
                                                                     'type': 'MObject'},
                                                       'obj': {'doc': 'the object to remove ',
                                                               'type': 'MDagPath'}},
                                           'args': [('obj',
                                                     'MDagPath',
                                                     'in'),
                                                    ('component',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRemove an object (DAG node) from the set.',
                                           'inArgs': ['obj', 'component'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'component': ['const',
                                                                            '&'],
                                                              'obj': ['const',
                                                                      '&']},
                                           'types': {'component': 'MObject',
                                                     'obj': 'MDagPath'}},
                                          {'argInfo': {'plug': {'doc': 'the plug to remove',
                                                                'type': 'MPlug'}},
                                           'args': [('plug',
                                                     'MPlug',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRemove an plug from the set.',
                                           'inArgs': ['plug'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'plug': ['const',
                                                                       '&']},
                                           'types': {'plug': 'MPlug'}}],
                         'removeMembers': [{'argInfo': {'list': {'doc': 'the selection list of items to remove',
                                                                 'type': 'MSelectionList'}},
                                            'args': [('list',
                                                      'MSelectionList',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nRemove items of the selection list from the set.',
                                            'inArgs': ['list'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'list': ['const',
                                                                        '&']},
                                            'types': {'list': 'MSelectionList'}}],
                         'restriction': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the type of membership restriction that this set has.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The type of restriction',
                                                         'qualifiers': [],
                                                         'type': ('MFnSet',
                                                                  'Restriction')},
                                          'returnType': ('MFnSet',
                                                         'Restriction'),
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                         'setAnnotation': [{'argInfo': {'annotation': {'doc': 'new annotation string',
                                                                       'type': 'MString'}},
                                            'args': [('annotation',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSets the annotation string for this set. This allows a description of the set to be stored with it.',
                                            'inArgs': ['annotation'],
                                            'inverse': ('annotation',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'annotation': ['const',
                                                                              '&']},
                                            'types': {'annotation': 'MString'}}],
                         'type': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nFunction set type. \r\n',
                                   'inArgs': [],
                                   'outArgs': [],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': ('MFn',
                                                           'Type')},
                                   'returnType': ('MFn', 'Type'),
                                   'static': False,
                                   'typeQualifiers': {},
                                   'types': {}}]},
             'pymelEnums': {'Restriction': "Enum('Restriction', [('none', 0), ('kNone', 0), ('verticesOnly', 1), ('kVerticesOnly', 1), ('edgesOnly', 2), ('kEdgesOnly', 2), ('facetsOnly', 3), ('kFacetsOnly', 3), ('editPointsOnly', 4), ('kEditPointsOnly', 4), ('renderableOnly', 5), ('kRenderableOnly', 5)], multiKeys=True)"},
             'pymelMethods': {'annotation': 'getAnnotation'}},
  'MFnSingleIndexedComponent': {'enums': {},
                                'invertibles': [('setCompleteData',
                                                 'getCompleteData')],
                                'methods': {'addElement': [{'argInfo': {'element': {'doc': 'the element index to be added',
                                                                                    'type': 'int'}},
                                                            'args': [('element',
                                                                      'int',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nAdd the specified element to the component.',
                                                            'inArgs': ['element'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'element': []},
                                                            'types': {'element': 'int'}}],
                                            'addElements': [{'argInfo': {'elements': {'doc': 'the array of element indices to be added',
                                                                                      'type': 'MIntArray'}},
                                                             'args': [('elements',
                                                                       'MIntArray',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nAdd the specified elements to the component.',
                                                             'inArgs': ['elements'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'elements': ['&']},
                                                             'types': {'elements': 'MIntArray'}}],
                                            'className': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nClass name. \r\n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'create': [{'argInfo': {'compType': {'doc': 'the type of component to create ',
                                                                                 'type': ('MFn',
                                                                                          'Type')}},
                                                        'args': [('compType',
                                                                  ('MFn',
                                                                   'Type'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nCreate a single indexed component of the given type. Allowable types are',
                                                        'inArgs': ['compType'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The new component',
                                                                       'qualifiers': [],
                                                                       'type': 'MObject'},
                                                        'returnType': 'MObject',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'compType': []},
                                                        'types': {'compType': ('MFn',
                                                                               'Type')}}],
                                            'element': [{'argInfo': {'index': {'doc': 'the index of the element to retrieve ',
                                                                               'type': 'int'}},
                                                         'args': [('index',
                                                                   'int',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the specified element from the component.',
                                                         'inArgs': ['index'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The index of the specified component',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'index': []},
                                                         'types': {'index': 'int'}}],
                                            'elementMax': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns the biggest element, plus 1, from the component.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The biggest index plus 1 of the specified component',
                                                                           'qualifiers': [],
                                                                           'type': 'int'},
                                                            'returnType': 'int',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                            'getCompleteData': [{'argInfo': {'numElements': {'doc': 'storage for the maximum number of elements',
                                                                                             'type': 'int'}},
                                                                 'args': [('numElements',
                                                                           'int',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nReturns the number of elements for the complete component. A complete component means that all elements are selected.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setCompleteData',
                                                                             False),
                                                                 'outArgs': ['numElements'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'numElements': ['&']},
                                                                 'types': {'numElements': 'int'}}],
                                            'getElements': [{'argInfo': {'elements': {'doc': 'storage for the array of indices',
                                                                                      'type': 'MIntArray'}},
                                                             'args': [('elements',
                                                                       'MIntArray',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nGet all of the element indices from the component.',
                                                             'inArgs': [],
                                                             'outArgs': ['elements'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'elements': ['&']},
                                                             'types': {'elements': 'MIntArray'}}],
                                            'setCompleteData': [{'argInfo': {'numElements': {'doc': 'the maximum number of elements in the component',
                                                                                             'type': 'int'}},
                                                                 'args': [('numElements',
                                                                           'int',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nMarks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].',
                                                                 'inArgs': ['numElements'],
                                                                 'inverse': ('getCompleteData',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'numElements': []},
                                                                 'types': {'numElements': 'int'}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nFunction set type. \r\n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                                'pymelEnums': {}},
  'MFnSkinCluster': {'enums': {},
                     'invertibles': [('setWeights', 'getWeights'),
                                     ('setBlendWeights', 'getBlendWeights')],
                     'methods': {'getBlendWeights': [{'argInfo': {'components': {'doc': 'the components to return weights for ',
                                                                                 'type': 'MObject'},
                                                                  'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                           'type': 'MDagPath'},
                                                                  'weights': {'doc': 'the weight values returned (one per component in the order given)',
                                                                              'type': 'MDoubleArray'}},
                                                      'args': [('path',
                                                                'MDagPath',
                                                                'in'),
                                                               ('components',
                                                                'MObject',
                                                                'in'),
                                                               ('weights',
                                                                'MDoubleArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nThis method returns weights from skinCluster's blend weight array. These weights are used to determine the blending between classical linear skinning and dual quaternion bases skinning on a per vertex basis. The function returns the weights associated with the components passed. The components are defined on the object whose dagPath is specified.",
                                                      'inArgs': ['path',
                                                                 'components'],
                                                      'inverse': ('setBlendWeights',
                                                                  False),
                                                      'outArgs': ['weights'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'components': ['const',
                                                                                        '&'],
                                                                         'path': ['const',
                                                                                  '&'],
                                                                         'weights': ['&']},
                                                      'types': {'components': 'MObject',
                                                                'path': 'MDagPath',
                                                                'weights': 'MDoubleArray'}}],
                                 'getPointsAffectedByInfluence': [{'argInfo': {'path': {'doc': 'path of the influence object ',
                                                                                        'type': 'MDagPath'},
                                                                               'result': {'doc': 'selection list of components affected by the influence object for this skinCluster (return) ',
                                                                                          'type': 'MSelectionList'},
                                                                               'weights': {'doc': 'weights for the affected components (return)',
                                                                                           'type': 'MDoubleArray'}},
                                                                   'args': [('path',
                                                                             'MDagPath',
                                                                             'in'),
                                                                            ('result',
                                                                             'MSelectionList',
                                                                             'out'),
                                                                            ('weights',
                                                                             'MDoubleArray',
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': "\r\nDuring deformation, the skinCluster algorithm is applied for a given influence object on all points in the deformer's set whose weights are non-zero. This method allows the user to query the non-zero weights for a particular influence object.",
                                                                   'inArgs': ['path'],
                                                                   'outArgs': ['result',
                                                                               'weights'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'path': ['const',
                                                                                               '&'],
                                                                                      'result': ['&'],
                                                                                      'weights': ['&']},
                                                                   'types': {'path': 'MDagPath',
                                                                             'result': 'MSelectionList',
                                                                             'weights': 'MDoubleArray'}},
                                                                  {'argInfo': {'path': {'doc': 'path of the influence object ',
                                                                                        'type': 'MDagPath'},
                                                                               'result': {'doc': 'selection list of components affected by the influence object for this skinCluster (return) ',
                                                                                          'type': 'MSelectionList'},
                                                                               'weights': {'doc': 'weights for the affected components (return)',
                                                                                           'type': 'MFloatArray'}},
                                                                   'args': [('path',
                                                                             'MDagPath',
                                                                             'in'),
                                                                            ('result',
                                                                             'MSelectionList',
                                                                             'out'),
                                                                            ('weights',
                                                                             'MFloatArray',
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': "\r\nThis method is obsolete. Maya's skinCluster nodes store their weights as doubles. This method has been replaced by one which uses doubles instead of floats. This method only exists for backwards-compilability of old plug-in code.",
                                                                   'inArgs': ['path'],
                                                                   'outArgs': ['result',
                                                                               'weights'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'path': ['const',
                                                                                               '&'],
                                                                                      'result': ['&'],
                                                                                      'weights': ['&']},
                                                                   'types': {'path': 'MDagPath',
                                                                             'result': 'MSelectionList',
                                                                             'weights': 'MFloatArray'}}],
                                 'getWeights': [{'argInfo': {'components': {'doc': 'components to return weights for ',
                                                                            'type': 'MObject'},
                                                             'influenceIndex': {'doc': 'physical index of influence object ',
                                                                                'type': 'uint'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'weights': {'doc': 'weight values',
                                                                         'type': 'MDoubleArray'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('influenceIndex',
                                                           'uint',
                                                           'in'),
                                                          ('weights',
                                                           'MDoubleArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGets the skinCluster weights for the influence object for the specified components of the object whose dagPath is specified. Note that if some of components are not deformed by the skinCluster, zeros will be returned as the weights. For example, on periodic nurbs surfaces, some of the cvs enforce the periodicity of the surface. There is no weight data for these components. They do not get deformed since their position is automatically maintained by the nurb so that the periodicity of the surface will not be lost. Zeros will be returned for such components.',
                                                 'inArgs': ['path',
                                                            'components',
                                                            'influenceIndex'],
                                                 'inverse': ('setWeights',
                                                             False),
                                                 'outArgs': ['weights'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceIndex': ['unsigned'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'weights': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndex': 'uint',
                                                           'path': 'MDagPath',
                                                           'weights': 'MDoubleArray'}},
                                                {'argInfo': {'components': {'doc': 'components to return weights for ',
                                                                            'type': 'MObject'},
                                                             'influenceCount': {'doc': 'count of influence objects',
                                                                                'type': 'uint'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'weights': {'doc': 'weight values returned (one per component, per influence) ',
                                                                         'type': 'MDoubleArray'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('weights',
                                                           'MDoubleArray',
                                                           'out'),
                                                          ('influenceCount',
                                                           'uint',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGets the skinCluster weights for all influenceObjects for the specified components of the object whose dagPath is specified. Returns the weights in an array of size number of components x number of influenceObjects. The array elements are ordered by components: i.e. all of the weight values for the first component first, followed by all the weight values for the next component, and so on. For the first component, the weights are ordered by influence object in the same order that is returned by the  MFnSkinCluster::influenceObjects  method.',
                                                 'inArgs': ['path',
                                                            'components'],
                                                 'inverse': ('setWeights',
                                                             False),
                                                 'outArgs': ['weights',
                                                             'influenceCount'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceCount': ['unsigned',
                                                                                       '&'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'weights': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceCount': 'uint',
                                                           'path': 'MDagPath',
                                                           'weights': 'MDoubleArray'}},
                                                {'argInfo': {'components': {'doc': 'components to return weights for ',
                                                                            'type': 'MObject'},
                                                             'influenceIndices': {'doc': 'indices of influence objects to get ',
                                                                                  'type': 'MIntArray'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'weights': {'doc': 'weight values returned (one per component, per influence)',
                                                                         'type': 'MDoubleArray'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('influenceIndices',
                                                           'MIntArray',
                                                           'in'),
                                                          ('weights',
                                                           'MDoubleArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGets the skinCluster weights for the influence objects for the specified components of the object whose dagPath is specified. Returns the weights in an array of size number of components x number of influence objects. The array elements are ordered by components: i.e. all of the weight values for the first component first, followed by all the weight values for the next component, and so on. For the first component, the weights are ordered by influence object in the same order as in influenceIndices.',
                                                 'inArgs': ['path',
                                                            'components',
                                                            'influenceIndices'],
                                                 'inverse': ('setWeights',
                                                             False),
                                                 'outArgs': ['weights'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceIndices': ['&'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'weights': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndices': 'MIntArray',
                                                           'path': 'MDagPath',
                                                           'weights': 'MDoubleArray'}},
                                                {'argInfo': {'components': {'doc': 'components to return weights for ',
                                                                            'type': 'MObject'},
                                                             'influenceIndex': {'doc': 'index of influence object ',
                                                                                'type': 'uint'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'weights': {'doc': 'weight values',
                                                                         'type': 'MFloatArray'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('influenceIndex',
                                                           'uint',
                                                           'in'),
                                                          ('weights',
                                                           'MFloatArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nThis method is obsolete. Maya's skinCluster nodes store their weights as doubles. This method has been replaced by one which uses doubles instead of floats. This method only exists for backwards-compilability of old plug-in code.",
                                                 'inArgs': ['path',
                                                            'components',
                                                            'influenceIndex'],
                                                 'inverse': ('setWeights',
                                                             False),
                                                 'outArgs': ['weights'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceIndex': ['unsigned'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'weights': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndex': 'uint',
                                                           'path': 'MDagPath',
                                                           'weights': 'MFloatArray'}},
                                                {'argInfo': {'components': {'doc': 'components to return weights for ',
                                                                            'type': 'MObject'},
                                                             'influenceCount': {'doc': 'count of influence objects',
                                                                                'type': 'uint'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'weights': {'doc': 'weight values returned (one per component, per influence) ',
                                                                         'type': 'MFloatArray'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('weights',
                                                           'MFloatArray',
                                                           'out'),
                                                          ('influenceCount',
                                                           'uint',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nThis method is obsolete. Maya's skinCluster nodes store their weights as doubles. This method has been replaced by one which uses doubles instead of floats. This method only exists for backwards-compilability of old plug-in code.",
                                                 'inArgs': ['path',
                                                            'components'],
                                                 'inverse': ('setWeights',
                                                             False),
                                                 'outArgs': ['weights',
                                                             'influenceCount'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceCount': ['unsigned',
                                                                                       '&'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'weights': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceCount': 'uint',
                                                           'path': 'MDagPath',
                                                           'weights': 'MFloatArray'}}],
                                 'indexForInfluenceObject': [{'argInfo': {'mpath': {'doc': 'path of the influence object ',
                                                                                    'type': 'MDagPath'}},
                                                              'args': [('mpath',
                                                                        'MDagPath',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nReturns the logical index of the matrix array attribute where the specified influence object is attached.',
                                                              'inArgs': ['mpath'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The logical index of the influence object',
                                                                             'qualifiers': [],
                                                                             'type': 'int'},
                                                              'returnType': 'int',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'mpath': ['const',
                                                                                           '&']},
                                                              'types': {'mpath': 'MDagPath'}}],
                                 'influenceObjects': [{'argInfo': {'paths': {'doc': 'influence objects ',
                                                                             'type': 'MDagPathArray'}},
                                                       'args': [(u'paths',
                                                                 'MDagPathArray',
                                                                 u'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns an array of paths to the influence objects for the skinCluster.',
                                                       'inArgs': [],
                                                       'outArgs': [u'paths'],
                                                       'returnInfo': {'doc': 'The number of influence objects',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'paths': ['&']},
                                                       'types': {'paths': 'MDagPathArray'}}],
                                 'setBlendWeights': [{'argInfo': {'components': {'doc': 'the components list for the new weight values ',
                                                                                 'type': 'MObject'},
                                                                  'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                           'type': 'MDagPath'},
                                                                  'weights': {'doc': 'the weight values (one per component in the order given)',
                                                                              'type': 'MDoubleArray'}},
                                                      'args': [(u'path',
                                                                'MDagPath',
                                                                'in'),
                                                               (u'components',
                                                                'MObject',
                                                                'in'),
                                                               (u'weights',
                                                                'MDoubleArray',
                                                                u'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nThis method sets weights in skinCluster's blend weight array. These weights are used to determine the blending between classical linear skinning and dual quaternion bases skinning on a per vertex basis. The function sets the weights for the given components of the object whose dagPath is specified. The array size should match the number of components passed. Failing this, it will set the smaller of the two.",
                                                      'inArgs': [u'path',
                                                                 u'components',
                                                                 u'weights'],
                                                      'inverse': ('getBlendWeights',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'components': ['const',
                                                                                        '&'],
                                                                         'path': ['const',
                                                                                  '&'],
                                                                         'weights': ['const',
                                                                                     '&']},
                                                      'types': {'components': 'MObject',
                                                                'path': 'MDagPath',
                                                                'weights': 'MDoubleArray'}}],
                                 'setWeights': [{'argInfo': {'components': {'doc': 'components to be weighted ',
                                                                            'type': 'MObject'},
                                                             'influenceIndex': {'doc': 'physical index of influence object for the weight ',
                                                                                'type': 'uint'},
                                                             'normalize': {'doc': 'whether or not to normalize weights on other influence objects ',
                                                                           'type': 'bool'},
                                                             'oldValues': {'doc': 'previous weight values, for undo',
                                                                           'type': 'MDoubleArray'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'value': {'doc': 'weight value ',
                                                                       'type': 'double'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('influenceIndex',
                                                           'uint',
                                                           'in'),
                                                          ('value',
                                                           'double',
                                                           'in'),
                                                          ('normalize',
                                                           'bool',
                                                           'in'),
                                                          ('oldValues',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {'normalize': True,
                                                              'oldValues': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the skinCluster weight for the influence object on the specified components of the object whose dagPath is specified. The influence is specified using the physical (non-sparse) index of the influence object. This corresponds to the order the influences are returned by the influenceObjects method.',
                                                 'inArgs': ['path',
                                                            'components',
                                                            'influenceIndex',
                                                            'value',
                                                            'normalize',
                                                            'oldValues'],
                                                 'inverse': ('getWeights',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceIndex': ['unsigned'],
                                                                    'normalize': [],
                                                                    'oldValues': ['*'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'value': []},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndex': 'uint',
                                                           'normalize': 'bool',
                                                           'oldValues': 'MDoubleArray',
                                                           'path': 'MDagPath',
                                                           'value': 'double'}},
                                                {'argInfo': {'components': {'doc': 'components to be weighted ',
                                                                            'type': 'MObject'},
                                                             'influenceIndices': {'doc': 'physical indices of influence objects to set ',
                                                                                  'type': 'MIntArray'},
                                                             'normalize': {'doc': 'whether or not to normalize weights on other influence objects ',
                                                                           'type': 'bool'},
                                                             'oldValues': {'doc': 'previous weight values, for undo',
                                                                           'type': 'MDoubleArray'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'values': {'doc': 'weight values ',
                                                                        'type': 'MDoubleArray'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('influenceIndices',
                                                           'MIntArray',
                                                           'in'),
                                                          ('values',
                                                           'MDoubleArray',
                                                           'in'),
                                                          ('normalize',
                                                           'bool',
                                                           'in'),
                                                          ('oldValues',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {'normalize': True,
                                                              'oldValues': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the skinCluster weight on the specified components of the object whose dagPath is specified for the influence objects corresponding to the specified influence indices. The influence is specified using the physical (non-sparse) index of the influence object. This corresponds to the order the influences are returned by the influenceObjects method.',
                                                 'inArgs': ['path',
                                                            'components',
                                                            'influenceIndices',
                                                            'values',
                                                            'normalize',
                                                            'oldValues'],
                                                 'inverse': ('getWeights',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceIndices': ['&'],
                                                                    'normalize': [],
                                                                    'oldValues': ['*'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'values': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndices': 'MIntArray',
                                                           'normalize': 'bool',
                                                           'oldValues': 'MDoubleArray',
                                                           'path': 'MDagPath',
                                                           'values': 'MDoubleArray'}},
                                                {'argInfo': {'components': {'doc': 'components to be weighted ',
                                                                            'type': 'MObject'},
                                                             'influenceIndex': {'doc': 'index of influence object for the weight ',
                                                                                'type': 'uint'},
                                                             'normalize': {'doc': 'whether or not to normalize weights on other influence objects ',
                                                                           'type': 'bool'},
                                                             'oldValues': {'doc': 'previous weight values, for undo',
                                                                           'type': 'MFloatArray'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'value': {'doc': 'weight value ',
                                                                       'type': 'float'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('influenceIndex',
                                                           'uint',
                                                           'in'),
                                                          ('value',
                                                           'float',
                                                           'in'),
                                                          ('normalize',
                                                           'bool',
                                                           'in'),
                                                          ('oldValues',
                                                           'MFloatArray',
                                                           'in')],
                                                 'defaults': {'normalize': True,
                                                              'oldValues': None},
                                                 'deprecated': False,
                                                 'doc': "\r\nThis method is obsolete. Maya's skinCluster nodes store their weights as doubles. This method has been replaced by one which uses doubles instead of floats. This method only exists for backwards-compilability of old plug-in code.",
                                                 'inArgs': ['path',
                                                            'components',
                                                            'influenceIndex',
                                                            'value',
                                                            'normalize',
                                                            'oldValues'],
                                                 'inverse': ('getWeights',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceIndex': ['unsigned'],
                                                                    'normalize': [],
                                                                    'oldValues': ['*'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'value': []},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndex': 'uint',
                                                           'normalize': 'bool',
                                                           'oldValues': 'MFloatArray',
                                                           'path': 'MDagPath',
                                                           'value': 'float'}},
                                                {'argInfo': {'components': {'doc': 'components to be weighted ',
                                                                            'type': 'MObject'},
                                                             'influenceIndices': {'doc': 'indices of influence objects to set ',
                                                                                  'type': 'MIntArray'},
                                                             'normalize': {'doc': 'whether or not to normalize weights on other influence objects ',
                                                                           'type': 'bool'},
                                                             'oldValues': {'doc': 'previous weight values, for undo',
                                                                           'type': 'MFloatArray'},
                                                             'path': {'doc': 'path to object deformed by the skinCluster ',
                                                                      'type': 'MDagPath'},
                                                             'values': {'doc': 'weight values ',
                                                                        'type': 'MFloatArray'}},
                                                 'args': [('path',
                                                           'MDagPath',
                                                           'in'),
                                                          ('components',
                                                           'MObject',
                                                           'in'),
                                                          ('influenceIndices',
                                                           'MIntArray',
                                                           'in'),
                                                          ('values',
                                                           'MFloatArray',
                                                           'in'),
                                                          ('normalize',
                                                           'bool',
                                                           'in'),
                                                          ('oldValues',
                                                           'MFloatArray',
                                                           'in')],
                                                 'defaults': {'normalize': True,
                                                              'oldValues': None},
                                                 'deprecated': False,
                                                 'doc': "\r\nThis method is obsolete. Maya's skinCluster nodes store their weights as doubles. This method has been replaced by one which uses doubles instead of floats. This method only exists for backwards-compilability of old plug-in code.",
                                                 'inArgs': ['path',
                                                            'components',
                                                            'influenceIndices',
                                                            'values',
                                                            'normalize',
                                                            'oldValues'],
                                                 'inverse': ('getWeights',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'components': ['const',
                                                                                   '&'],
                                                                    'influenceIndices': ['&'],
                                                                    'normalize': [],
                                                                    'oldValues': ['*'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'values': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndices': 'MIntArray',
                                                           'normalize': 'bool',
                                                           'oldValues': 'MFloatArray',
                                                           'path': 'MDagPath',
                                                           'values': 'MFloatArray'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnSphereData': {'enums': {},
                    'invertibles': [('setRadius', 'radius')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nClass name. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {'rad': {'doc': 'the radius of the new sphere ',
                                                                'type': 'double'}},
                                            'args': [('rad',
                                                      'double',
                                                      'in')],
                                            'defaults': {'rad': 1.0},
                                            'deprecated': False,
                                            'doc': '\nCreate a new sphere of the given radius, and attach it to this instance as an  MObject .',
                                            'inArgs': ['rad'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The new MObject ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'rad': []},
                                            'types': {'rad': 'double'}}],
                                'radius': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturn the radius of the sphere attached to this instance.',
                                            'inArgs': [],
                                            'inverse': ('setRadius',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The radius ',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'setRadius': [{'argInfo': {'rad': {'doc': 'the new radius',
                                                                   'type': 'double'}},
                                               'args': [('rad',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nChange the radius of the sphere attached to this instance instance as an  MObject .',
                                               'inArgs': ['rad'],
                                               'inverse': ('radius',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'rad': []},
                                               'types': {'rad': 'double'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nFunction set type. \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'radius': 'getRadius'}},
  'MFnSpotLight': {'enums': {'MBarnDoor': {'valueDocs': {'bottom': '',
                                                         'kBottom': '',
                                                         'kLeft': '',
                                                         'kRight': '',
                                                         'kTop': '',
                                                         'left': '',
                                                         'right': '',
                                                         'top': ''},
                                           'values': "Enum('MBarnDoor', {'kLeft': 0, 'kRight': 1, 'kTop': 2, 'kBottom': 3})"},
                             'MDecayRegion': {'valueDocs': {'first': '',
                                                            'kFirst': '',
                                                            'kSecond': '',
                                                            'kThird': '',
                                                            'second': '',
                                                            'third': ''},
                                              'values': "Enum('MDecayRegion', {'kFirst': 0, 'kSecond': 1, 'kThird': 2})"}},
                   'invertibles': [('setBarnDoorAngle', 'barnDoorAngle'),
                                   ('setDropOff', 'dropOff'),
                                   ('setEndDistance', 'endDistance'),
                                   ('setBarnDoors', 'barnDoors'),
                                   ('setStartDistance', 'startDistance'),
                                   ('setPenumbraAngle', 'penumbraAngle'),
                                   ('setUseDecayRegions',
                                    'useDecayRegions'),
                                   ('setConeAngle', 'coneAngle')],
                   'methods': {'barnDoorAngle': [{'argInfo': {'which_door': {'doc': 'which barn door to return. ',
                                                                             'type': ('MFnSpotLight',
                                                                                      'MBarnDoor')}},
                                                  'args': [('which_door',
                                                            ('MFnSpotLight',
                                                             'MBarnDoor'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieves the value of the barn door angle for the specified barn door. The barn door angles are represented by the "leftBarnDoor", "rightBarnDoor", "topBarnDoor", and "bottomBarnDoor" attributes. This function retrieves the value of the appropriate attribute.',
                                                  'inArgs': ['which_door'],
                                                  'inverse': ('setBarnDoorAngle',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the appropriate barn door angle attribute of the light node.',
                                                                 'qualifiers': [],
                                                                 'type': 'double',
                                                                 'unitType': u'angular'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'which_door': []},
                                                  'types': {'which_door': ('MFnSpotLight',
                                                                           'MBarnDoor')}}],
                               'barnDoors': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRetrieves the value of the "barnDoors" attribute of a light node. This attribute determines whether or not the light uses barn doors.',
                                              'inArgs': [],
                                              'inverse': ('setBarnDoors',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the "barnDoors" attribute of the light node.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClass name. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'coneAngle': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRetrieves the value of the "coneAngle" attribute of a light node. This attribute represents the angle that the spotlight cone makes with the spotlight direction vector.',
                                              'inArgs': [],
                                              'inverse': ('setConeAngle',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the "coneAngle" attribute of the light node.',
                                                             'qualifiers': [],
                                                             'type': 'double',
                                                             'unitType': u'angular'},
                                              'returnType': 'double',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                     'type': 'bool'}},
                                           'args': [('UIvisible',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'UIvisible': True},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new spotlight dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                           'inArgs': ['UIvisible'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'UIvisible': []},
                                           'types': {'UIvisible': 'bool'}},
                                          {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                     'type': 'bool'},
                                                       'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                  'type': 'MObject'},
                                                       'wantTransform': {'doc': "Boolean to indicate whether the transform node is needed or not, which is 'false' by default. ",
                                                                         'type': 'bool'}},
                                           'args': [('parent',
                                                     'MObject',
                                                     'in'),
                                                    ('UIvisible',
                                                     'bool',
                                                     'in'),
                                                    ('wantTransform',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'UIvisible': True,
                                                        'wantTransform': False},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new spotlight dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                           'inArgs': ['parent',
                                                      'UIvisible',
                                                      'wantTransform'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'UIvisible': [],
                                                              'parent': ['const',
                                                                         '&'],
                                                              'wantTransform': []},
                                           'types': {'UIvisible': 'bool',
                                                     'parent': 'MObject',
                                                     'wantTransform': 'bool'}},
                                          {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                     'type': 'bool'},
                                                       'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                  'type': 'MObject'}},
                                           'args': [('parent',
                                                     'MObject',
                                                     'in'),
                                                    ('UIvisible',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'UIvisible': True},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['parent',
                                                      'UIvisible'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'UIvisible': [],
                                                              'parent': ['const',
                                                                         '&']},
                                           'types': {'UIvisible': 'bool',
                                                     'parent': 'MObject'}}],
                               'dropOff': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nRetrieves the value of the "dropOff" attribute of a light node. This attribute represents the degree to which intensity of the light decreases with increasing angular distance from the light direction vector. Higher values represent more rapid intensity dropoff.',
                                            'inArgs': [],
                                            'inverse': ('setDropOff',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The value of the "dropOff" attribute of the light node.',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                               'endDistance': [{'argInfo': {'which_region': {'doc': 'the decay region whose endDistance attribute is to be retrieved. ',
                                                                             'type': ('MFnSpotLight',
                                                                                      'MDecayRegion')}},
                                                'args': [('which_region',
                                                          ('MFnSpotLight',
                                                           'MDecayRegion'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRetrieves the value of the end distance for the specified decay regions. The end distances for the spotlight\'s 3 decay regions are represented by the "endDistance1", "endDistance2", and "endDistance3" attributes. This function retrieves the value of the appropriate attribute.',
                                                'inArgs': ['which_region'],
                                                'inverse': ('setEndDistance',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The value of the appropriate endDistance attribute of the light node.',
                                                               'qualifiers': [],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'which_region': []},
                                                'types': {'which_region': ('MFnSpotLight',
                                                                           'MDecayRegion')}}],
                               'penumbraAngle': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieves the value of the "penumbraAngle" attribute of a light node. This attribute represents the extra angle beyond the cone angle used in soft shadow computations.',
                                                  'inArgs': [],
                                                  'inverse': ('setPenumbraAngle',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the "penumbraAngle" attribute of the light node.',
                                                                 'qualifiers': [],
                                                                 'type': 'double',
                                                                 'unitType': u'angular'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                               'setBarnDoorAngle': [{'argInfo': {'barn_door_angle': {'doc': 'New value for the barn door.',
                                                                                     'type': 'double',
                                                                                     'unitType': u'angular'},
                                                                 'which_door': {'doc': 'Which barn door to return. ',
                                                                                'type': ('MFnSpotLight',
                                                                                         'MBarnDoor')}},
                                                     'args': [('which_door',
                                                               ('MFnSpotLight',
                                                                'MBarnDoor'),
                                                               'in'),
                                                              ('barn_door_angle',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the value of the appropriate barn door angle attribute of a light node.',
                                                     'inArgs': ['which_door',
                                                                'barn_door_angle'],
                                                     'inverse': ('barnDoorAngle',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'barn_door_angle': ['const',
                                                                                            '&'],
                                                                        'which_door': []},
                                                     'types': {'barn_door_angle': 'double',
                                                               'which_door': ('MFnSpotLight',
                                                                              'MBarnDoor')}}],
                               'setBarnDoors': [{'argInfo': {'barn_doors': {'doc': 'value to which the attribute will be set.',
                                                                            'type': 'bool'}},
                                                 'args': [('barn_doors',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the value of the "barnDoors" attribute of a light node.',
                                                 'inArgs': ['barn_doors'],
                                                 'inverse': ('barnDoors',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'barn_doors': ['const',
                                                                                   '&']},
                                                 'types': {'barn_doors': 'bool'}}],
                               'setConeAngle': [{'argInfo': {'cone_angle': {'doc': 'value to which the attribute will be set.',
                                                                            'type': 'double',
                                                                            'unitType': u'angular'}},
                                                 'args': [('cone_angle',
                                                           'double',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the value of the "coneAngle" attribute of a light node.',
                                                 'inArgs': ['cone_angle'],
                                                 'inverse': ('coneAngle',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'cone_angle': ['const',
                                                                                   '&']},
                                                 'types': {'cone_angle': 'double'}}],
                               'setDropOff': [{'argInfo': {'drop_off': {'doc': 'value to which the attribute will be set.',
                                                                        'type': 'double'}},
                                               'args': [('drop_off',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSets the value of the "dropOff" attribute of a light node.',
                                               'inArgs': ['drop_off'],
                                               'inverse': ('dropOff',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'drop_off': ['const',
                                                                               '&']},
                                               'types': {'drop_off': 'double'}}],
                               'setEndDistance': [{'argInfo': {'end_distance': {'doc': 'value to which the attribute will be set.',
                                                                                'type': 'float'},
                                                               'which_region': {'doc': 'the decay region whose end distance is to be set. ',
                                                                                'type': ('MFnSpotLight',
                                                                                         'MDecayRegion')}},
                                                   'args': [('which_region',
                                                             ('MFnSpotLight',
                                                              'MDecayRegion'),
                                                             'in'),
                                                            ('end_distance',
                                                             'float',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the value of the appropriate decay region end distance attribute of a light node.',
                                                   'inArgs': ['which_region',
                                                              'end_distance'],
                                                   'inverse': ('endDistance',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'end_distance': ['const',
                                                                                       '&'],
                                                                      'which_region': []},
                                                   'types': {'end_distance': 'float',
                                                             'which_region': ('MFnSpotLight',
                                                                              'MDecayRegion')}}],
                               'setPenumbraAngle': [{'argInfo': {'penumbra_angle': {'doc': 'value to which the attribute will be set.',
                                                                                    'type': 'double',
                                                                                    'unitType': u'angular'}},
                                                     'args': [('penumbra_angle',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the value of the "penumbraAngle" attribute of a light node.',
                                                     'inArgs': ['penumbra_angle'],
                                                     'inverse': ('penumbraAngle',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'penumbra_angle': ['const',
                                                                                           '&']},
                                                     'types': {'penumbra_angle': 'double'}}],
                               'setStartDistance': [{'argInfo': {'start_distance': {'doc': 'value to which the attribute will be set.',
                                                                                    'type': 'float'},
                                                                 'which_region': {'doc': 'the decay region whose start distance is to be set. ',
                                                                                  'type': ('MFnSpotLight',
                                                                                           'MDecayRegion')}},
                                                     'args': [('which_region',
                                                               ('MFnSpotLight',
                                                                'MDecayRegion'),
                                                               'in'),
                                                              ('start_distance',
                                                               'float',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the value of the appropriate decay region start distance attribute of a light node.',
                                                     'inArgs': ['which_region',
                                                                'start_distance'],
                                                     'inverse': ('startDistance',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'start_distance': ['const',
                                                                                           '&'],
                                                                        'which_region': []},
                                                     'types': {'start_distance': 'float',
                                                               'which_region': ('MFnSpotLight',
                                                                                'MDecayRegion')}}],
                               'setUseDecayRegions': [{'argInfo': {'use_decay_regions': {'doc': 'value to which the attribute will be set.',
                                                                                         'type': 'bool'}},
                                                       'args': [('use_decay_regions',
                                                                 'bool',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the value of the "useDecayRegions" attribute of a light node.',
                                                       'inArgs': ['use_decay_regions'],
                                                       'inverse': ('useDecayRegions',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'use_decay_regions': ['const',
                                                                                                '&']},
                                                       'types': {'use_decay_regions': 'bool'}}],
                               'startDistance': [{'argInfo': {'which_region': {'doc': 'the decay region whose startDistance attribute is to be retrieved. ',
                                                                               'type': ('MFnSpotLight',
                                                                                        'MDecayRegion')}},
                                                  'args': [('which_region',
                                                            ('MFnSpotLight',
                                                             'MDecayRegion'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieves the value of the start distance for the specified decay regions. The start distances for the spotlight\'s 3 decay regions are represented by the "startDistance1", "startDistance2", and "startDistance3" attributes. This function retrieves the value of the appropriate attribute.',
                                                  'inArgs': ['which_region'],
                                                  'inverse': ('setStartDistance',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the appropriate startDistance attribute of the light node.',
                                                                 'qualifiers': [],
                                                                 'type': 'float'},
                                                  'returnType': 'float',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'which_region': []},
                                                  'types': {'which_region': ('MFnSpotLight',
                                                                             'MDecayRegion')}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'useDecayRegions': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRetrieves the value of the "useDecayRegions" attribute of a light node. This attribute determines whether or not the light uses decay regions.',
                                                    'inArgs': [],
                                                    'inverse': ('setUseDecayRegions',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the "useDecayRegions" attribute of the light node.',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}]},
                   'pymelEnums': {'MBarnDoor': "Enum('MBarnDoor', [('left', 0), ('kLeft', 0), ('right', 1), ('kRight', 1), ('top', 2), ('kTop', 2), ('bottom', 3), ('kBottom', 3)], multiKeys=True)",
                                  'MDecayRegion': "Enum('MDecayRegion', [('first', 0), ('kFirst', 0), ('second', 1), ('kSecond', 1), ('third', 2), ('kThird', 2)], multiKeys=True)"},
                   'pymelMethods': {'barnDoorAngle': 'getBarnDoorAngle',
                                    'barnDoors': 'getBarnDoors',
                                    'coneAngle': 'getConeAngle',
                                    'dropOff': 'getDropOff',
                                    'endDistance': 'getEndDistance',
                                    'penumbraAngle': 'getPenumbraAngle',
                                    'startDistance': 'getStartDistance',
                                    'useDecayRegions': 'getUseDecayRegions'}},
  'MFnStateManip': {'enums': {},
                    'invertibles': [('setMaxStates', 'maxStates')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'connectToStatePlug': [{'argInfo': {'statePlug': {'doc': 'the state plug',
                                                                                  'type': 'MPlug'}},
                                                        'args': [('statePlug',
                                                                  'MPlug',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nConnect to the state plug. The data type corresponding to the statePlug is a int integer.',
                                                        'inArgs': ['statePlug'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'statePlug': ['&']},
                                                        'types': {'statePlug': 'MPlug'}}],
                                'create': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\r\nCreates a new StateManip. This function set's object is set to be the new manipulator.",
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Newly created StateManip',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}},
                                           {'argInfo': {'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                      'type': 'MString'},
                                                        'stateName': {'doc': 'Label for the state value which appears in the feedback line. ',
                                                                      'type': 'MString'}},
                                            'args': [('manipName',
                                                      'MString',
                                                      'in'),
                                                     ('stateName',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\r\nCreates a new StateManip. This function set's object is set to be the new manipulator.",
                                            'inArgs': ['manipName',
                                                       'stateName'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Newly created StateManip',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'manipName': ['const',
                                                                             '&'],
                                                               'stateName': ['const',
                                                                             '&']},
                                            'types': {'manipName': 'MString',
                                                      'stateName': 'MString'}}],
                                'maxStates': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the number of maximum states.',
                                               'inArgs': [],
                                               'inverse': ('setMaxStates',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Maximum states',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                'positionIndex': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the index of the position of the StateManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Position index',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                'setInitialState': [{'argInfo': {'initialState': {'doc': 'initial state of the StateManip',
                                                                                  'type': 'uint'}},
                                                     'args': [('initialState',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the initial state of the StateManip.',
                                                     'inArgs': ['initialState'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'initialState': ['unsigned']},
                                                     'types': {'initialState': 'uint'}}],
                                'setMaxStates': [{'argInfo': {'numStates': {'doc': 'the maxiumum number of states',
                                                                            'type': 'uint'}},
                                                  'args': [('numStates',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets the maximum number of states that the StateManip will have. The default number of maximum states is 4.',
                                                  'inArgs': ['numStates'],
                                                  'inverse': ('maxStates',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'numStates': ['unsigned']},
                                                  'types': {'numStates': 'uint'}}],
                                'state': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the current state.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Current states',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                                'stateIndex': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the index of the state. The data type corresponding to this index is a int integer.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'State index',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'maxStates': 'getMaxStates'}},
  'MFnStringArrayData': {'enums': {},
                         'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the MString to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nExtract the indicated  MString  from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return an  MString  containing "".',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated MString ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}},
                                                     {'argInfo': {'index': {'doc': 'the index of the MString to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated MString ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                                     'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn an  MStringArray  containing the string array currently operated upon by the function set. The  MStringArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A copy of the MStringArray held in this instance ',
                                                               'qualifiers': [],
                                                               'type': 'MStringArray'},
                                                'returnType': 'MStringArray',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nClass name. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MStringArray to populate',
                                                                      'type': 'MStringArray'}},
                                                 'args': [('dest',
                                                           'MStringArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCopy all the strings in the instance into the given  MStringArray .',
                                                 'inArgs': [],
                                                 'outArgs': ['dest'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'dest': ['&']},
                                                 'types': {'dest': 'MStringArray'}}],
                                     'create': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to contain no strings.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                     'type': 'MStringArray'}},
                                                 'args': [('arr',
                                                           'MStringArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MStringArray .',
                                                 'inArgs': ['arr'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MStringArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the number of strings in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of strings in the instance ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                     'set': [{'argInfo': {'element': {'doc': 'the element ',
                                                                      'type': 'MString'},
                                                          'index': {'doc': 'the index of the MString to set',
                                                                    'type': 'uint'}},
                                              'args': [('element',
                                                        'MString',
                                                        'in'),
                                                       ('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the element at the specified index of the array.',
                                              'inArgs': ['element',
                                                         'index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'element': ['const',
                                                                             '&'],
                                                                 'index': ['unsigned']},
                                              'types': {'element': 'MString',
                                                        'index': 'uint'}},
                                             {'argInfo': {'array': {'doc': 'the MStringArray containing the data to set into this instance',
                                                                    'type': 'MStringArray'}},
                                              'args': [('array',
                                                        'MStringArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the instance to contain the strings defined in the given  MStringArray .',
                                              'inArgs': ['array'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['const',
                                                                           '&']},
                                              'types': {'array': 'MStringArray'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFunction set type. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnStringData': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClass name. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {'str': {'doc': 'the string to copy ',
                                                                'type': 'MString'}},
                                            'args': [('str',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it to a copy of the given string.',
                                            'inArgs': ['str'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The new MObject ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'str': ['const',
                                                                       '&']},
                                            'types': {'str': 'MString'}},
                                           {'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreate a new  MObject , attach it to this instance and initialize it to the null string.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The new MObject ',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'set': [{'argInfo': {'string': {'doc': 'the MString to copy',
                                                                'type': 'MString'}},
                                         'args': [('string',
                                                   'MString',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSet this instance to hold a copy of the given string.',
                                         'inArgs': ['string'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'string': ['const',
                                                                       '&']},
                                         'types': {'string': 'MString'}}],
                                'string': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn a copy of the string held in this instance.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'An MString containing the string ',
                                                           'qualifiers': [],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nFunction set type. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {}},
  'MFnSubd': {'enums': {},
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nClass name. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'collapse': [{'argInfo': {'level': {'doc': 'the number of levels of the hierarchy to collapse ',
                                                              'type': 'int'},
                                                    'makeNewNodeInvisible': {'doc': 'sets the invisible attribute of the new node ',
                                                                             'type': 'bool'}},
                                        'args': [('level', 'int', 'in'),
                                                 ('makeNewNodeInvisible',
                                                  'bool',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThis method creates a copy of a given source subdivision surface collapsed by the given number of levels. After the collapse this function set will operate on the new subdivision surface.',
                                        'inArgs': ['level',
                                                   'makeNewNodeInvisible'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The new collapsed subdivision object',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                           'level': ['const'],
                                                           'makeNewNodeInvisible': []},
                                        'types': {'level': 'int',
                                                  'makeNewNodeInvisible': 'bool'}}],
                          'convertToNurbs': [{'argInfo': {'newNurbsSurfaces': {'doc': 'Storage for the arary of NURBS',
                                                                               'type': 'MObjectArray'}},
                                              'args': [('newNurbsSurfaces',
                                                        'MObjectArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nConverts this surface to a set of nurbs surfaces.',
                                              'inArgs': [],
                                              'outArgs': ['newNurbsSurfaces'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'newNurbsSurfaces': ['&']},
                                              'types': {'newNurbsSurfaces': 'MObjectArray'}}],
                          'copy': [{'argInfo': {'parentOrOwner': {'doc': 'the DAG parent or kSubdivData the new subdivision surface will belong to ',
                                                                  'type': 'MObject'},
                                                'source': {'doc': 'the subdivision surface to be copied ',
                                                           'type': 'MObject'}},
                                    'args': [('source', 'MObject', 'in'),
                                             ('parentOrOwner',
                                              'MObject',
                                              'in')],
                                    'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                    'deprecated': False,
                                    'doc': '\r\nThis method creates a copy of a given source subdivision surface. After the copy this function set will operate on the new subdivision surface.',
                                    'inArgs': ['source', 'parentOrOwner'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kSubdivData  ',
                                                   'qualifiers': [],
                                                   'type': 'MObject'},
                                    'returnType': 'MObject',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                       'parentOrOwner': [],
                                                       'source': ['const',
                                                                  '&']},
                                    'types': {'parentOrOwner': 'MObject',
                                              'source': 'MObject'}}],
                          'creasesClearAll': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nClear all crease information from this surface. No vertices or edges will be creased after this function completes.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                          'creasesGetAll': [{'argInfo': {'edgeIds': {'doc': 'The ids of the edges that are creased',
                                                                     'type': 'MUint64Array'},
                                                         'vertexIds': {'doc': 'The ids of the vertices that are creased ',
                                                                       'type': 'MUint64Array'}},
                                             'args': [('vertexIds',
                                                       'MUint64Array',
                                                       'out'),
                                                      ('edgeIds',
                                                       'MUint64Array',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns all creases on the subdivision surface in two arrays of 64-bit ids; one for the vertices, one for edges.',
                                             'inArgs': [],
                                             'outArgs': ['vertexIds',
                                                         'edgeIds'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'edgeIds': ['&'],
                                                                'vertexIds': ['&']},
                                             'types': {'edgeIds': 'MUint64Array',
                                                       'vertexIds': 'MUint64Array'}}],
                          'creasesSetAll': [{'argInfo': {'edgeIds': {'doc': 'The ids of the edges that are creased',
                                                                     'type': 'MUint64Array'},
                                                         'vertexIds': {'doc': 'The ids of the vertices that are creased ',
                                                                       'type': 'MUint64Array'}},
                                             'args': [('vertexIds',
                                                       'MUint64Array',
                                                       'in'),
                                                      ('edgeIds',
                                                       'MUint64Array',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the creases on all vertices and edges with a given 64-bit name. Note that the combination of  creasesGetAll()  and  creasesSetAll()  will not exactly duplicate the crease information between two surfaces.',
                                             'inArgs': ['vertexIds',
                                                        'edgeIds'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'edgeIds': ['const',
                                                                            '&'],
                                                                'vertexIds': ['const',
                                                                              '&']},
                                             'types': {'edgeIds': 'MUint64Array',
                                                       'vertexIds': 'MUint64Array'}}],
                          'createBaseMesh': [{'argInfo': {'numPolygons': {'doc': 'number of polygons ',
                                                                          'type': 'int'},
                                                          'numVertices': {'doc': 'number of vertices ',
                                                                          'type': 'int'},
                                                          'parentOrOwner': {'doc': 'parent of the polygon that will be created ',
                                                                            'type': 'MObject'},
                                                          'polygonConnects': {'doc': 'array of vertex connections for each polygon ',
                                                                              'type': 'MIntArray'},
                                                          'polygonCounts': {'doc': 'array of vertex counts for each polygon ',
                                                                            'type': 'MIntArray'},
                                                          'reverseNormal': {'doc': 'Not currently used ',
                                                                            'type': 'bool'},
                                                          'vertexArray': {'doc': 'point (vertex) array ',
                                                                          'type': 'MPointArray'}},
                                              'args': [('reverseNormal',
                                                        'bool',
                                                        'in'),
                                                       ('numVertices',
                                                        'int',
                                                        'in'),
                                                       ('numPolygons',
                                                        'int',
                                                        'in'),
                                                       ('vertexArray',
                                                        'MPointArray',
                                                        'in'),
                                                       ('polygonCounts',
                                                        'MIntArray',
                                                        'in'),
                                                       ('polygonConnects',
                                                        'MIntArray',
                                                        'in'),
                                                       ('parentOrOwner',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                              'deprecated': False,
                                              'doc': '\r\nCreates a new subdivision surface given an array of vertices and connection information and sets this function set to operate on the new surface.',
                                              'inArgs': ['reverseNormal',
                                                         'numVertices',
                                                         'numPolygons',
                                                         'vertexArray',
                                                         'polygonCounts',
                                                         'polygonConnects',
                                                         'parentOrOwner'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kSubdivData  ',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'numPolygons': [],
                                                                 'numVertices': [],
                                                                 'parentOrOwner': [],
                                                                 'polygonConnects': ['const',
                                                                                     '&'],
                                                                 'polygonCounts': ['const',
                                                                                   '&'],
                                                                 'reverseNormal': [],
                                                                 'vertexArray': ['const',
                                                                                 '&']},
                                              'types': {'numPolygons': 'int',
                                                        'numVertices': 'int',
                                                        'parentOrOwner': 'MObject',
                                                        'polygonConnects': 'MIntArray',
                                                        'polygonCounts': 'MIntArray',
                                                        'reverseNormal': 'bool',
                                                        'vertexArray': 'MPointArray'}}],
                          'edgeAdjacentPolygon': [{'argInfo': {'edgeId': {'doc': 'The 64-bit edge name ',
                                                                          'type': 'MUint64'},
                                                               'polys': {'doc': 'The 64-bit names of the polygons (1 or 2)',
                                                                         'type': 'MUint64Array'}},
                                                   'args': [('edgeId',
                                                             'MUint64',
                                                             'in'),
                                                            ('polys',
                                                             'MUint64Array',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the polygons adjacent to this edge. There can be at most two, as non-manifold topology is not allowed.',
                                                   'inArgs': ['edgeId'],
                                                   'outArgs': ['polys'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'edgeId': [],
                                                                      'polys': ['&']},
                                                   'types': {'edgeId': 'MUint64',
                                                             'polys': 'MUint64Array'}}],
                          'edgeBetween': [{'argInfo': {'vertex1': {'doc': 'The name of the first vertex ',
                                                                   'type': 'MUint64'},
                                                       'vertex2': {'doc': 'The name of the second vertex ',
                                                                   'type': 'MUint64'}},
                                           'args': [('vertex1',
                                                     'MUint64',
                                                     'in'),
                                                    ('vertex2',
                                                     'MUint64',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\r\nReturn the name of the edge that connects the two vertices. If the edge doesn't exist, it will be created.",
                                           'inArgs': ['vertex1',
                                                      'vertex2'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The name of the edge between the two',
                                                          'qualifiers': [],
                                                          'type': 'MUint64'},
                                           'returnType': 'MUint64',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'vertex1': [],
                                                              'vertex2': []},
                                           'types': {'vertex1': 'MUint64',
                                                     'vertex2': 'MUint64'}}],
                          'edgeChildren': [{'argInfo': {'children': {'doc': '64-bit names of the children of this edge',
                                                                     'type': 'MUint64Array'},
                                                        'edgeId': {'doc': '64-bit name of the edge ',
                                                                   'type': 'MUint64'}},
                                            'args': [('edgeId',
                                                      'MUint64',
                                                      'in'),
                                                     ('children',
                                                      'MUint64Array',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the "children" of the particular edge. If the edge has children, there will always be two child edges.',
                                            'inArgs': ['edgeId'],
                                            'outArgs': ['children'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'children': ['&'],
                                                               'edgeId': []},
                                            'types': {'children': 'MUint64Array',
                                                      'edgeId': 'MUint64'}}],
                          'edgeCount': [{'argInfo': {'level': {'doc': "The level where we're counting the edges ",
                                                               'type': 'int'}},
                                         'args': [('level', 'int', 'in')],
                                         'defaults': {'level': 0},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the number of edges at a level.',
                                         'inArgs': ['level'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Number of edges at the given level',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'level': []},
                                         'types': {'level': 'int'}}],
                          'edgeCreaseRelevant': [{'argInfo': {'edgeId': {'doc': 'The edge 64-bit name ',
                                                                         'type': 'MUint64'}},
                                                  'args': [('edgeId',
                                                            'MUint64',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn true if the crease of the edge is a relevant piece of information. The edge inherits the crease state from its parent. So, its crease state is relevant only if different from its parent (or if there is no direct parent edge).',
                                                  'inArgs': ['edgeId'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Whether the edge has relevant crease information',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'edgeId': []},
                                                  'types': {'edgeId': 'MUint64'}}],
                          'edgeIsBoundary': [{'argInfo': {'edgeId': {'doc': 'The 64-bit edge name ',
                                                                     'type': 'MUint64'}},
                                              'args': [('edgeId',
                                                        'MUint64',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nTest if the edge specified is a boundary edge or not.',
                                              'inArgs': ['edgeId'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'True if the edge is a boundary edge, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'edgeId': []},
                                              'types': {'edgeId': 'MUint64'}}],
                          'edgeIsCreased': [{'argInfo': {'edgeId': {'doc': 'The 64-bit name of the edge ',
                                                                    'type': 'MUint64'}},
                                             'args': [('edgeId',
                                                       'MUint64',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn true if the edge is creased.',
                                             'inArgs': ['edgeId'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'True if the edge is creased, false otherwise',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'edgeId': []},
                                             'types': {'edgeId': 'MUint64'}}],
                          'edgeIsValid': [{'argInfo': {'edgeId': {'doc': 'The 64-bit edge name ',
                                                                  'type': 'MUint64'}},
                                           'args': [('edgeId',
                                                     'MUint64',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns true if the specified edge name is valid.',
                                           'inArgs': ['edgeId'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'True if the edge name is valid, false otherwise.',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'edgeId': []},
                                           'types': {'edgeId': 'MUint64'}}],
                          'edgeSetCrease': [{'argInfo': {'creased': {'doc': 'Crease (true) or smooth (false)',
                                                                     'type': 'bool'},
                                                         'edgeId': {'doc': 'The 64-bit name of the edge ',
                                                                    'type': 'MUint64'}},
                                             'args': [('edgeId',
                                                       'MUint64',
                                                       'in'),
                                                      ('creased',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nSet the particular edge's crease state.",
                                             'inArgs': ['edgeId',
                                                        'creased'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'creased': [],
                                                                'edgeId': []},
                                             'types': {'creased': 'bool',
                                                       'edgeId': 'MUint64'}}],
                          'edgeVertices': [{'argInfo': {'edgeId': {'doc': 'The 64-bit edge name ',
                                                                   'type': 'MUint64'},
                                                        'v1': {'doc': 'First vertex on the edge ',
                                                               'type': 'MUint64'},
                                                        'v2': {'doc': 'Second vertex on the edge',
                                                               'type': 'MUint64'}},
                                            'args': [('edgeId',
                                                      'MUint64',
                                                      'in'),
                                                     ('v1',
                                                      'MUint64',
                                                      'out'),
                                                     ('v2',
                                                      'MUint64',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGiven an edge, return the two vertices at its ends.',
                                            'inArgs': ['edgeId'],
                                            'outArgs': ['v1', 'v2'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'edgeId': [],
                                                               'v1': ['&'],
                                                               'v2': ['&']},
                                            'types': {'edgeId': 'MUint64',
                                                      'v1': 'MUint64',
                                                      'v2': 'MUint64'}}],
                          'editsPending': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nAs the new hierarchical vertex offsets are being introduced, you can choose to not apply them to the surface immediatelly. If you do that, the number of edits pending will increase. Any edits are not actually made until you call "updateEdits". This functions lets you know if you need to call it or not.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Edits pending (1) or not (0).',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                          'editsUpdateAll': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nIf there are pending edits, this function will update the surface so that there are no pending edits.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                          'evaluateNormal': [{'argInfo': {'nrml': {'doc': 'The resulting surface normal',
                                                                   'type': 'MVector'},
                                                          'polyId': {'doc': 'The 64-bit polygon name ',
                                                                     'type': 'MUint64'},
                                                          'u': {'doc': 'U value on the face ',
                                                                'type': 'double'},
                                                          'uvNormalized': {'doc': 'If true, its as if U, V are in [0,1] ',
                                                                           'type': 'bool'},
                                                          'v': {'doc': 'V value on the face ',
                                                                'type': 'double'}},
                                              'args': [('polyId',
                                                        'MUint64',
                                                        'in'),
                                                       ('u',
                                                        'double',
                                                        'in'),
                                                       ('v',
                                                        'double',
                                                        'in'),
                                                       ('uvNormalized',
                                                        'bool',
                                                        'in'),
                                                       ('nrml',
                                                        'MVector',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nEvaluate the surface normal at the given parameter point on the polygon. The limitation is that this cannot be a base mesh polygon; i.e., it has to be at least level 1.',
                                              'inArgs': ['polyId',
                                                         'u',
                                                         'v',
                                                         'uvNormalized'],
                                              'outArgs': ['nrml'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'nrml': ['&'],
                                                                 'polyId': [],
                                                                 'u': [],
                                                                 'uvNormalized': [],
                                                                 'v': []},
                                              'types': {'nrml': 'MVector',
                                                        'polyId': 'MUint64',
                                                        'u': 'double',
                                                        'uvNormalized': 'bool',
                                                        'v': 'double'}}],
                          'evaluatePosition': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                       'type': 'MUint64'},
                                                            'pos': {'doc': 'The resulting 3d position',
                                                                    'type': 'MPoint'},
                                                            'u': {'doc': 'U value on the face ',
                                                                  'type': 'double'},
                                                            'uvNormalized': {'doc': 'If true, its as if U, V are in [0,1] ',
                                                                             'type': 'bool'},
                                                            'v': {'doc': 'V value on the face ',
                                                                  'type': 'double'}},
                                                'args': [('polyId',
                                                          'MUint64',
                                                          'in'),
                                                         ('u',
                                                          'double',
                                                          'in'),
                                                         ('v',
                                                          'double',
                                                          'in'),
                                                         ('uvNormalized',
                                                          'bool',
                                                          'in'),
                                                         ('pos',
                                                          'MPoint',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nEvaluate the surface position at the given parameter point on the polygon. The limitation is that this cannot be a base mesh polygon; i.e., it has to be at least level 1.',
                                                'inArgs': ['polyId',
                                                           'u',
                                                           'v',
                                                           'uvNormalized'],
                                                'outArgs': ['pos'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'polyId': [],
                                                                   'pos': ['&'],
                                                                   'u': [],
                                                                   'uvNormalized': [],
                                                                   'v': []},
                                                'types': {'polyId': 'MUint64',
                                                          'pos': 'MPoint',
                                                          'u': 'double',
                                                          'uvNormalized': 'bool',
                                                          'v': 'double'}}],
                          'evaluatePositionAndNormal': [{'argInfo': {'nrml': {'doc': 'The resulting surface normal',
                                                                              'type': 'MVector'},
                                                                     'polyId': {'doc': 'The 64-bit polygon name ',
                                                                                'type': 'MUint64'},
                                                                     'pos': {'doc': 'The resulting 3d position ',
                                                                             'type': 'MPoint'},
                                                                     'u': {'doc': 'U value on the face ',
                                                                           'type': 'double'},
                                                                     'uvNormalized': {'doc': 'If true, its as if U, V are in [0,1] ',
                                                                                      'type': 'bool'},
                                                                     'v': {'doc': 'V value on the face ',
                                                                           'type': 'double'}},
                                                         'args': [('polyId',
                                                                   'MUint64',
                                                                   'in'),
                                                                  ('u',
                                                                   'double',
                                                                   'in'),
                                                                  ('v',
                                                                   'double',
                                                                   'in'),
                                                                  ('uvNormalized',
                                                                   'bool',
                                                                   'in'),
                                                                  ('pos',
                                                                   'MPoint',
                                                                   'out'),
                                                                  ('nrml',
                                                                   'MVector',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nEvaluate the surface position and normal at the given parameter point on the polygon. The limitation is that this cannot be a base mesh polygon; i.e., it has to be at least level 1.',
                                                         'inArgs': ['polyId',
                                                                    'u',
                                                                    'v',
                                                                    'uvNormalized'],
                                                         'outArgs': ['pos',
                                                                     'nrml'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'nrml': ['&'],
                                                                            'polyId': [],
                                                                            'pos': ['&'],
                                                                            'u': [],
                                                                            'uvNormalized': [],
                                                                            'v': []},
                                                         'types': {'nrml': 'MVector',
                                                                   'polyId': 'MUint64',
                                                                   'pos': 'MPoint',
                                                                   'u': 'double',
                                                                   'uvNormalized': 'bool',
                                                                   'v': 'double'}}],
                          'getConnectedShaders': [{'argInfo': {'faces': {'doc': 'Storage for indices matching faces to indices ',
                                                                         'type': 'MUint64Array'},
                                                               'indices': {'doc': 'Storage for indices matching indices to shaders',
                                                                           'type': 'MIntArray'},
                                                               'instanceNumber': {'doc': 'The instance number of the subdivision surface to query ',
                                                                                  'type': 'uint'},
                                                               'shaders': {'doc': 'Storage for set objects (shader objects) ',
                                                                           'type': 'MObjectArray'}},
                                                   'args': [('instanceNumber',
                                                             'uint',
                                                             'in'),
                                                            ('shaders',
                                                             'MObjectArray',
                                                             'out'),
                                                            ('faces',
                                                             'MUint64Array',
                                                             'out'),
                                                            ('indices',
                                                             'MIntArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns all the shaders (sets) connected to the specified instance of this subdivision surface and two arrays indicating face/shader assignments. For each face in the face array, there is a corresponding entry in the indices array to indicate the assigned shader in the shader array.',
                                                   'inArgs': ['instanceNumber'],
                                                   'outArgs': ['shaders',
                                                               'faces',
                                                               'indices'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'faces': ['&'],
                                                                      'indices': ['&'],
                                                                      'instanceNumber': ['unsigned'],
                                                                      'shaders': ['&']},
                                                   'types': {'faces': 'MUint64Array',
                                                             'indices': 'MIntArray',
                                                             'instanceNumber': 'uint',
                                                             'shaders': 'MObjectArray'}}],
                          'getCubicSpline': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                     'type': 'MUint64'},
                                                          'vertices': {'doc': 'point array ',
                                                                       'type': 'MPointArray'}},
                                              'args': [('polyId',
                                                        'MUint64',
                                                        'in'),
                                                       ('vertices',
                                                        'MPointArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSome of the faces (usually at level 2 or below) happen to be exactly the same as uniform bi-cubic B-splines. This routine will return the 16 points that define such spline.',
                                              'inArgs': ['polyId'],
                                              'outArgs': ['vertices'],
                                              'returnInfo': {'doc': 'True if we can make the conversion, false otherwise',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'polyId': [],
                                                                 'vertices': []},
                                              'types': {'polyId': 'MUint64',
                                                        'vertices': 'MPointArray'}},
                                             {'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                     'type': 'MUint64'},
                                                          'vertices': {'doc': '16 vertices that define the cubic spline ',
                                                                       'type': 'MPoint__array16'}},
                                              'args': [('polyId',
                                                        'MUint64',
                                                        'in'),
                                                       ('vertices',
                                                        'MPoint__array16',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['polyId'],
                                              'outArgs': ['vertices'],
                                              'returnInfo': {'doc': 'True if we can make the conversion, false otherwise',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'polyId': [],
                                                                 'vertices': []},
                                              'types': {'polyId': 'MUint64',
                                                        'vertices': 'MPoint__array16'}}],
                          'levelFullySubdivideTo': [{'argInfo': {'level': {'doc': 'The level to which to fully subdivide ',
                                                                           'type': 'int'}},
                                                     'args': [('level',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nFully subdivide the whole surface to the specified level. This could be very expensive, so be careful, or you will run out of memory. As a rule, each level has 4 times more faces than the previous one.',
                                                     'inArgs': ['level'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'level': []},
                                                     'types': {'level': 'int'}}],
                          'levelMaxAllowed': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the maximum level that can be created. You should probably avoid fully subdividing the surface to that level as you will most likelly just run out of memory.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The maximum possibly value for the finest level in the hierarchy',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'levelMaxCurrent': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the finest level that currently exist. As int as a single face exists at a level, that level is counted. Note that this not mean that all of the faces exist on all levels.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The finest level in the hierarchy',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'polygonBaseMeshAdd': [{'argInfo': {'vertexCount': {'doc': 'Number of vertices in the polygon ',
                                                                              'type': 'int'},
                                                              'vertexIndex': {'doc': 'The vertex indices (0, 1, 2, ...) ',
                                                                              'type': 'int__array'}},
                                                  'args': [('vertexCount',
                                                            'int',
                                                            'in'),
                                                           ('vertexIndex',
                                                            'int__array',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAdd a polygon at the base mesh level. You will need to use the index names of the vertices (remember, they get their 64-bit names only after they have been added to a polygon).',
                                                  'inArgs': ['vertexCount',
                                                             'vertexIndex'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The name of the newly created polygon',
                                                                 'qualifiers': [],
                                                                 'type': 'MUint64'},
                                                  'returnType': 'MUint64',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'vertexCount': [],
                                                                     'vertexIndex': ['const']},
                                                  'types': {'vertexCount': 'int',
                                                            'vertexIndex': 'int__array'}}],
                          'polygonBaseMeshAddWithUVs': [{'argInfo': {'uValues': {'doc': 'U values for each vertex ',
                                                                                 'type': 'double__array'},
                                                                     'vValues': {'doc': 'V values for each vertex ',
                                                                                 'type': 'double__array'},
                                                                     'vertexCount': {'doc': 'Number of vertices in the polygon ',
                                                                                     'type': 'int'},
                                                                     'vertexIds': {'doc': 'The vertex indices (0, 1, 2, ...) ',
                                                                                   'type': 'int__array'}},
                                                         'args': [('vertexCount',
                                                                   'int',
                                                                   'in'),
                                                                  ('vertexIds',
                                                                   'int__array',
                                                                   'in'),
                                                                  ('uValues',
                                                                   'double__array',
                                                                   'in'),
                                                                  ('vValues',
                                                                   'double__array',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nAdd a polygon at the base mesh level. You will need to use the index names of the vertices (remember, they get their 64-bit names only after they have been added to a polygon). Specify the UV values as well.',
                                                         'inArgs': ['vertexCount',
                                                                    'vertexIds',
                                                                    'uValues',
                                                                    'vValues'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The name of the newly created polygon',
                                                                        'qualifiers': [],
                                                                        'type': 'MUint64'},
                                                         'returnType': 'MUint64',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'uValues': ['const'],
                                                                            'vValues': ['const'],
                                                                            'vertexCount': [],
                                                                            'vertexIds': ['const']},
                                                         'types': {'uValues': 'double__array',
                                                                   'vValues': 'double__array',
                                                                   'vertexCount': 'int',
                                                                   'vertexIds': 'int__array'}}],
                          'polygonChildren': [{'argInfo': {'children': {'doc': 'The 64-bit name of the child polygons',
                                                                        'type': 'MUint64Array'},
                                                           'polyId': {'doc': 'The 64-bit name of the original polygon ',
                                                                      'type': 'MUint64'}},
                                               'args': [('polyId',
                                                         'MUint64',
                                                         'in'),
                                                        ('children',
                                                         'MUint64Array',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the list of children polygons on the given polygon. If the children array is not empty, we will just append to it.',
                                               'inArgs': ['polyId'],
                                               'outArgs': ['children'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'children': ['&'],
                                                                  'polyId': []},
                                               'types': {'children': 'MUint64Array',
                                                         'polyId': 'MUint64'}}],
                          'polygonCount': [{'argInfo': {'level': {'doc': "Level at which we're counting ",
                                                                  'type': 'int'}},
                                            'args': [('level',
                                                      'int',
                                                      'in')],
                                            'defaults': {'level': 0},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the number of polygons currently existing at the specified level of the hierarchy.',
                                            'inArgs': ['level'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The number of polygons at the specified level',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'level': []},
                                            'types': {'level': 'int'}}],
                          'polygonCountMaxWithGivenBaseMesh': [{'argInfo': {'level': {'doc': 'The level where you would be counting ',
                                                                                      'type': 'int'}},
                                                                'args': [('level',
                                                                          'int',
                                                                          'in')],
                                                                'defaults': {'level': 1},
                                                                'deprecated': False,
                                                                'doc': '\r\nIf you were to fully subdivide at a given level, how many polygons would you have at that level? This function will tell you and possibly save you from running out of memory if you go too deep. Note that this is exactly the same as "polygonCount" for levels 0 and 1.',
                                                                'inArgs': ['level'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'The number of polygons at the given level if you were to fully subdivide at that level.',
                                                                               'qualifiers': [],
                                                                               'type': 'int'},
                                                                'returnType': 'int',
                                                                'static': False,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'level': []},
                                                                'types': {'level': 'int'}}],
                          'polygonEdgeCount': [{'argInfo': {'polyId': {'doc': 'The 64-bit name of the polygon ',
                                                                       'type': 'MUint64'}},
                                                'args': [('polyId',
                                                          'MUint64',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThe number of edges on the given polygon.',
                                                'inArgs': ['polyId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of edges on this polygon',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'polyId': []},
                                                'types': {'polyId': 'MUint64'}}],
                          'polygonEdges': [{'argInfo': {'edgeIds': {'doc': 'The 64-bit names of the edges',
                                                                    'type': 'MUint64Array'},
                                                        'polyId': {'doc': 'The 64-bit name of the polygon ',
                                                                   'type': 'MUint64'}},
                                            'args': [('polyId',
                                                      'MUint64',
                                                      'in'),
                                                     ('edgeIds',
                                                      'MUint64Array',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGiven the polygon, return its edges. The edges are at the same level as the polygon.',
                                            'inArgs': ['polyId'],
                                            'outArgs': ['edgeIds'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'edgeIds': ['&'],
                                                               'polyId': []},
                                            'types': {'edgeIds': 'MUint64Array',
                                                      'polyId': 'MUint64'}}],
                          'polygonGetCenterUV': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                         'type': 'MUint64'},
                                                              'u': {'doc': 'The resulting U value ',
                                                                    'type': 'double'},
                                                              'v': {'doc': 'The resulting V value',
                                                                    'type': 'double'}},
                                                  'args': [('polyId',
                                                            'MUint64',
                                                            'in'),
                                                           ('u',
                                                            'double',
                                                            'out'),
                                                           ('v',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the UV values in the "center" of this polygon.',
                                                  'inArgs': ['polyId'],
                                                  'outArgs': ['u', 'v'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'polyId': [],
                                                                     'u': ['&'],
                                                                     'v': ['&']},
                                                  'types': {'polyId': 'MUint64',
                                                            'u': 'double',
                                                            'v': 'double'}}],
                          'polygonGetVertexUVs': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                          'type': 'MUint64'},
                                                               'uValues': {'doc': 'Array of U values ',
                                                                           'type': 'MDoubleArray'},
                                                               'vValues': {'doc': 'Array of V values',
                                                                           'type': 'MDoubleArray'}},
                                                   'args': [('polyId',
                                                             'MUint64',
                                                             'in'),
                                                            ('uValues',
                                                             'MDoubleArray',
                                                             'out'),
                                                            ('vValues',
                                                             'MDoubleArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the vertex UVs from the polygon. The values come back in exactly the same order as the polygon vertices do.',
                                                   'inArgs': ['polyId'],
                                                   'outArgs': ['uValues',
                                                               'vValues'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'polyId': [],
                                                                      'uValues': ['&'],
                                                                      'vValues': ['&']},
                                                   'types': {'polyId': 'MUint64',
                                                             'uValues': 'MDoubleArray',
                                                             'vValues': 'MDoubleArray'}}],
                          'polygonHasChildren': [{'argInfo': {'polyId': {'doc': 'The polygon 64-bit name ',
                                                                         'type': 'MUint64'}},
                                                  'args': [('polyId',
                                                            'MUint64',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns whether or not the given polygon has children.',
                                                  'inArgs': ['polyId'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Whether the polygon has children.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'polyId': []},
                                                  'types': {'polyId': 'MUint64'}}],
                          'polygonHasVertexUVs': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                          'type': 'MUint64'}},
                                                   'args': [('polyId',
                                                             'MUint64',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns true if there are user specified UVs on this polygon.',
                                                   'inArgs': ['polyId'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if there were explicitly specified UVs on this polygon.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'polyId': []},
                                                   'types': {'polyId': 'MUint64'}}],
                          'polygonIsValid': [{'argInfo': {'polygonId': {'doc': 'The polygon 64-bit name ',
                                                                        'type': 'MUint64'}},
                                              'args': [('polygonId',
                                                        'MUint64',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn true if the polygon is a valid polygon.',
                                              'inArgs': ['polygonId'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Whether the polygon is valid or not. Valid means that the polygon has been instantiated on the surface. Not all polygons at all levels exist by default. A polygon only exists if it was created at the time the subdiv was first created or if the subdiv was refined.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'polygonId': []},
                                              'types': {'polygonId': 'MUint64'}}],
                          'polygonSetUseUVs': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                       'type': 'MUint64'},
                                                            'useThem': {'doc': 'Use the user set UVs',
                                                                        'type': 'bool'}},
                                                'args': [('polyId',
                                                          'MUint64',
                                                          'in'),
                                                         ('useThem',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nIf this is set, the polygon will use the user specified UVs.',
                                                'inArgs': ['polyId',
                                                           'useThem'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'polyId': [],
                                                                   'useThem': []},
                                                'types': {'polyId': 'MUint64',
                                                          'useThem': 'bool'}}],
                          'polygonSetVertexUVs': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name ',
                                                                          'type': 'MUint64'},
                                                               'uValues': {'doc': 'Array of U values ',
                                                                           'type': 'MDoubleArray'},
                                                               'vValues': {'doc': 'Array of V values',
                                                                           'type': 'MDoubleArray'}},
                                                   'args': [('polyId',
                                                             'MUint64',
                                                             'in'),
                                                            ('uValues',
                                                             'MDoubleArray',
                                                             'in'),
                                                            ('vValues',
                                                             'MDoubleArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the UV values on the polygon.',
                                                   'inArgs': ['polyId',
                                                              'uValues',
                                                              'vValues'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'polyId': [],
                                                                      'uValues': ['const',
                                                                                  '&'],
                                                                      'vValues': ['const',
                                                                                  '&']},
                                                   'types': {'polyId': 'MUint64',
                                                             'uValues': 'MDoubleArray',
                                                             'vValues': 'MDoubleArray'}}],
                          'polygonSubdivide': [{'argInfo': {'polyId': {'doc': 'The 64-bit name of the polygon',
                                                                       'type': 'MUint64'}},
                                                'args': [('polyId',
                                                          'MUint64',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSubdivide the given polygon into 4 children (if this happens to be the level 0 polygon you will get as many children as that polygon has edges).',
                                                'inArgs': ['polyId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'polyId': []},
                                                'types': {'polyId': 'MUint64'}}],
                          'polygonVertexCount': [{'argInfo': {'polyId': {'doc': 'The 64-bit name of the polygon ',
                                                                         'type': 'MUint64'}},
                                                  'args': [('polyId',
                                                            'MUint64',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nHow many vertices on a given polygon? The vertices are at the same level as the polygon.',
                                                  'inArgs': ['polyId'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The number of vertices on this polygon',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'polyId': []},
                                                  'types': {'polyId': 'MUint64'}}],
                          'polygonVertices': [{'argInfo': {'polyId': {'doc': 'The 64-bit name of the polygon ',
                                                                      'type': 'MUint64'},
                                                           'vertexIds': {'doc': 'The 64-bit names of the vertices',
                                                                         'type': 'MUint64Array'}},
                                               'args': [('polyId',
                                                         'MUint64',
                                                         'in'),
                                                        ('vertexIds',
                                                         'MUint64Array',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGiven the polygon, return its vertices. The vertices are at the same level as the polygon.',
                                               'inArgs': ['polyId'],
                                               'outArgs': ['vertexIds'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'polyId': [],
                                                                  'vertexIds': ['&']},
                                               'types': {'polyId': 'MUint64',
                                                         'vertexIds': 'MUint64Array'}}],
                          'tesselate': [{'argInfo': {'depth': {'doc': 'Used in the uniform tesselation: how deep do we go ',
                                                               'type': 'int'},
                                                     'parentOrOwner': {'doc': 'the DAG parent or kMeshData the new Mesh will belong to ',
                                                                       'type': 'MObject'},
                                                     'sample': {'doc': 'In both tesselation cases, once we decide which level to tesselate at, how many times do we sample. ',
                                                                'type': 'int'},
                                                     'uniform': {'doc': 'Use uniform tesselation if this is set. ',
                                                                 'type': 'bool'}},
                                         'args': [('uniform',
                                                   'bool',
                                                   'in'),
                                                  ('depth', 'int', 'in'),
                                                  ('sample',
                                                   'int',
                                                   'in'),
                                                  ('parentOrOwner',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nPerforms tesselation on this surface and create a new mesh in the DAG. The parentOrOwner argument is used to specify the owner of the new surface.',
                                         'inArgs': ['uniform',
                                                    'depth',
                                                    'sample',
                                                    'parentOrOwner'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'depth': [],
                                                            'parentOrOwner': [],
                                                            'sample': [],
                                                            'uniform': []},
                                         'types': {'depth': 'int',
                                                   'parentOrOwner': 'MObject',
                                                   'sample': 'int',
                                                   'uniform': 'bool'}}],
                          'tessellateViaNurbs': [{'argInfo': {'parentOrOwner': {'doc': 'the DAG parent or kMeshData the new Mesh will belong to ',
                                                                                'type': 'MObject'}},
                                                  'args': [('parentOrOwner',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                                  'deprecated': False,
                                                  'doc': '\r\nPerforms tesselation on this surface and create a new mesh in the DAG. The parentOrOwner argument is used to specify the owner of the new surface.',
                                                  'inArgs': ['parentOrOwner'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' If parentOrOwner is NULL then the transform for this surface is returned  If parentOrOwner is a DAG object then the new surface shape is returned  The surface geometry is returned if parentOrOwner is of type kMeshData  ',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'parentOrOwner': []},
                                                  'types': {'parentOrOwner': 'MObject'}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nFunction set type. \r\n',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': ('MFn',
                                                            'Type')},
                                    'returnType': ('MFn', 'Type'),
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                          'updateAllEditsAndCreases': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nIf you have been editing offsets without updating the surface, this function will save you. This will dirty up the complete surface and recompute the positions of all the cvs, updating the crease info along the way. Not cheap to call.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                          'updateSubdSurface': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSignal that this subdivision surface has changed and needs to redraw itself.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                          'vertexAdjacentVertices': [{'argInfo': {'vertList': {'doc': 'The resulting list of adjacent vertices',
                                                                               'type': 'MUint64Array'},
                                                                  'vertexId': {'doc': 'The vertex 64-bit name ',
                                                                               'type': 'MUint64'}},
                                                      'args': [('vertexId',
                                                                'MUint64',
                                                                'in'),
                                                               ('vertList',
                                                                'MUint64Array',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn the list of adjacent vertices as their 64-bit ids.',
                                                      'inArgs': ['vertexId'],
                                                      'outArgs': ['vertList'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'vertList': ['&'],
                                                                         'vertexId': []},
                                                      'types': {'vertList': 'MUint64Array',
                                                                'vertexId': 'MUint64'}}],
                          'vertexBaseIndexFromVertexId': [{'argInfo': {'vertexId': {'doc': 'The 64-bit name of the vertex ',
                                                                                    'type': 'MUint64'}},
                                                           'args': [('vertexId',
                                                                     'MUint64',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nGiven a 64-bit id of the vertex, return its index (0, 1, ...) if it happens to be a base mesh vertex. It is an error to call this function with a non base mesh vertex.',
                                                           'inArgs': ['vertexId'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The index in the base mesh vertex array of this vertex',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'vertexId': []},
                                                           'types': {'vertexId': 'MUint64'}}],
                          'vertexBaseMeshAdd': [{'argInfo': {'x': {'doc': 'X location of the vertex ',
                                                                   'type': 'double'},
                                                             'y': {'doc': 'Y location of the vertex ',
                                                                   'type': 'double'},
                                                             'z': {'doc': 'Z location of the vertex ',
                                                                   'type': 'double'}},
                                                 'args': [('x',
                                                           'double',
                                                           'in'),
                                                          ('y',
                                                           'double',
                                                           'in'),
                                                          ('z',
                                                           'double',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdd a vertex to the base mesh and return its "index" name. Note that it will not have a valid 64-bit name until you actually create a polygon that holds it.',
                                                 'inArgs': ['x',
                                                            'y',
                                                            'z'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The index of the newly created vertex. It will be -1 if the creation failed.',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'x': [],
                                                                    'y': [],
                                                                    'z': []},
                                                 'types': {'x': 'double',
                                                           'y': 'double',
                                                           'z': 'double'}}],
                          'vertexBaseMeshAddWithIndex': [{'argInfo': {'index': {'doc': 'The index the vertex is to take',
                                                                                'type': 'int'},
                                                                      'x': {'doc': 'X location of the vertex ',
                                                                            'type': 'double'},
                                                                      'y': {'doc': 'Y location of the vertex ',
                                                                            'type': 'double'},
                                                                      'z': {'doc': 'Z location of the vertex ',
                                                                            'type': 'double'}},
                                                          'args': [('x',
                                                                    'double',
                                                                    'in'),
                                                                   ('y',
                                                                    'double',
                                                                    'in'),
                                                                   ('z',
                                                                    'double',
                                                                    'in'),
                                                                   ('index',
                                                                    'int',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nVery similar to vertexBaseMeshAdd, this gives you an advanced option of specifying the index for the new vertex to be created. You have to be extremelly careful to end up with the indices 0, 1, ... N-1 for N total vertices.',
                                                          'inArgs': ['x',
                                                                     'y',
                                                                     'z',
                                                                     'index'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'index': [],
                                                                             'x': [],
                                                                             'y': [],
                                                                             'z': []},
                                                          'types': {'index': 'int',
                                                                    'x': 'double',
                                                                    'y': 'double',
                                                                    'z': 'double'}}],
                          'vertexBaseMeshGet': [{'argInfo': {'positions': {'doc': 'The array of point positions ',
                                                                           'type': 'MPointArray'},
                                                             'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                       'type': ('MSpace',
                                                                                'Space')}},
                                                 'args': [('positions',
                                                           'MPointArray',
                                                           'out'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in')],
                                                 'defaults': {'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject')},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn all base mesh vertices in the array using their indices (not the 64-bit names).',
                                                 'inArgs': ['space'],
                                                 'outArgs': ['positions'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'positions': ['&'],
                                                                    'space': []},
                                                 'types': {'positions': 'MPointArray',
                                                           'space': ('MSpace',
                                                                     'Space')}}],
                          'vertexBaseMeshGetWithId': [{'argInfo': {'positions': {'doc': 'The array of point positions ',
                                                                                 'type': 'MPointArray'},
                                                                   'space': {'doc': 'The space we are working in',
                                                                             'type': ('MSpace',
                                                                                      'Space')},
                                                                   'vertexIds': {'doc': 'The vertex 64-bit ids ',
                                                                                 'type': 'MUint64Array'}},
                                                       'args': [('positions',
                                                                 'MPointArray',
                                                                 'out'),
                                                                ('vertexIds',
                                                                 'MUint64Array',
                                                                 'out'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject')},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn all base mesh vertices in the array using their indices but also provide the 64-bit names.',
                                                       'inArgs': ['space'],
                                                       'outArgs': ['positions',
                                                                   'vertexIds'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'positions': ['&'],
                                                                          'space': [],
                                                                          'vertexIds': ['&']},
                                                       'types': {'positions': 'MPointArray',
                                                                 'space': ('MSpace',
                                                                           'Space'),
                                                                 'vertexIds': 'MUint64Array'}}],
                          'vertexBaseMeshSet': [{'argInfo': {'positions': {'doc': 'The positions for the vertices ',
                                                                           'type': 'MPointArray'},
                                                             'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                       'type': ('MSpace',
                                                                                'Space')}},
                                                 'args': [('positions',
                                                           'MPointArray',
                                                           'out'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in')],
                                                 'defaults': {'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject')},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet the positions for the base mesh vertices using the 0, 1,... indexing instead of the 64-bit vertex names.',
                                                 'inArgs': ['space'],
                                                 'outArgs': ['positions'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'positions': ['const',
                                                                                  '&'],
                                                                    'space': []},
                                                 'types': {'positions': 'MPointArray',
                                                           'space': ('MSpace',
                                                                     'Space')}}],
                          'vertexBaseMeshSetWithId': [{'argInfo': {'positions': {'doc': 'The positions for the vertices ',
                                                                                 'type': 'MPointArray'},
                                                                   'space': {'doc': 'The space we are working in',
                                                                             'type': ('MSpace',
                                                                                      'Space')},
                                                                   'vertexIds': {'doc': 'The vertex 64-bit ids ',
                                                                                 'type': 'MUint64Array'}},
                                                       'args': [('positions',
                                                                 'MPointArray',
                                                                 'out'),
                                                                ('vertexIds',
                                                                 'MUint64Array',
                                                                 'out'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject')},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet the positions for the base mesh vertices using the 64-bit names. The ordering of the elements in the array is irrelevant. The edits will be automatically updated (i.e.,  editsPending()  will return 0 after the call to this function).',
                                                       'inArgs': ['space'],
                                                       'outArgs': ['positions',
                                                                   'vertexIds'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'positions': ['const',
                                                                                        '&'],
                                                                          'space': [],
                                                                          'vertexIds': ['const',
                                                                                        '&']},
                                                       'types': {'positions': 'MPointArray',
                                                                 'space': ('MSpace',
                                                                           'Space'),
                                                                 'vertexIds': 'MUint64Array'}}],
                          'vertexChildren': [{'argInfo': {'children': {'doc': '64-bit names of the children of this vertex',
                                                                       'type': 'MUint64Array'},
                                                          'vertexId': {'doc': '64-bit name of the vertex ',
                                                                       'type': 'MUint64'}},
                                              'args': [('vertexId',
                                                        'MUint64',
                                                        'in'),
                                                       ('children',
                                                        'MUint64Array',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the "children" of the particular vertex if they exist. The children are defined as the finer-level version of the current vertex plus the neighbors of that vertex. For a valence n vertex this means 2n+1 vertices are returned if a finer level exists.',
                                              'inArgs': ['vertexId'],
                                              'outArgs': ['children'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'children': ['&'],
                                                                 'vertexId': []},
                                              'types': {'children': 'MUint64Array',
                                                        'vertexId': 'MUint64'}}],
                          'vertexCount': [{'argInfo': {'level': {'doc': 'The level we are interested in ',
                                                                 'type': 'int'}},
                                           'args': [('level',
                                                     'int',
                                                     'in')],
                                           'defaults': {'level': 0},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the finest vertex count at a particular level. These are the vertices that are currently instantiated.',
                                           'inArgs': ['level'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of vertices at the given level',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'level': []},
                                           'types': {'level': 'int'}}],
                          'vertexCreaseRelevant': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name ',
                                                                             'type': 'MUint64'}},
                                                    'args': [('vertexId',
                                                              'MUint64',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn true if the crease of the vertex is a relevant piece of information. The vertex inherits the crease state from its parent. So, its crease state is relevant only if different from its parent (or if there is no direct parent vertex).',
                                                    'inArgs': ['vertexId'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Whether the vertex has relevant crease information',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'vertexId': []},
                                                    'types': {'vertexId': 'MUint64'}}],
                          'vertexEditGet': [{'argInfo': {'edit': {'doc': 'The offset in object space ',
                                                                  'type': 'MVector'},
                                                         'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                   'type': ('MSpace',
                                                                            'Space')},
                                                         'vertexId': {'doc': 'The name of the vertex ',
                                                                      'type': 'MUint64'}},
                                             'args': [('vertexId',
                                                       'MUint64',
                                                       'in'),
                                                      ('edit',
                                                       'MVector',
                                                       'out'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nGet the offset of the specified vertex from its original position. This vector really is  vertexPositionGet()  -  vertexPositionGetNoEdit() .',
                                             'inArgs': ['vertexId',
                                                        'space'],
                                             'outArgs': ['edit'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'edit': ['&'],
                                                                'space': [],
                                                                'vertexId': []},
                                             'types': {'edit': 'MVector',
                                                       'space': ('MSpace',
                                                                 'Space'),
                                                       'vertexId': 'MUint64'}}],
                          'vertexEditSet': [{'argInfo': {'edit': {'doc': 'The offset to set ',
                                                                  'type': 'MVector'},
                                                         'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                   'type': ('MSpace',
                                                                            'Space')},
                                                         'updateEdits': {'doc': 'If false, you will need to call updateSubdSurface() before any change would be applied. Further, you must set this to true before you start calling the same function on the vertices of the finer levels. ',
                                                                         'type': 'bool'},
                                                         'vertexId': {'doc': 'The name of the vertex ',
                                                                      'type': 'MUint64'}},
                                             'args': [('vertexId',
                                                       'MUint64',
                                                       'in'),
                                                      ('edit',
                                                       'MVector',
                                                       'in'),
                                                      ('updateEdits',
                                                       'bool',
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nSet the original position offset for the given vertex.',
                                             'inArgs': ['vertexId',
                                                        'edit',
                                                        'updateEdits',
                                                        'space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'edit': ['const',
                                                                         '&'],
                                                                'space': [],
                                                                'updateEdits': [],
                                                                'vertexId': []},
                                             'types': {'edit': 'MVector',
                                                       'space': ('MSpace',
                                                                 'Space'),
                                                       'updateEdits': 'bool',
                                                       'vertexId': 'MUint64'}}],
                          'vertexEditsClearAllNonBase': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nFind all vertices with edits and remove those edits, setting them back to their original position.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                          'vertexEditsGetAllNonBase': [{'argInfo': {'edits': {'doc': 'The offsets from the original position ',
                                                                              'type': 'MVectorArray'},
                                                                    'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                              'type': ('MSpace',
                                                                                       'Space')},
                                                                    'vertexIds': {'doc': 'The names of the vertices ',
                                                                                  'type': 'MUint64Array'}},
                                                        'args': [('vertexIds',
                                                                  'MUint64Array',
                                                                  'in'),
                                                                 ('edits',
                                                                  'MVectorArray',
                                                                  'in'),
                                                                 ('space',
                                                                  ('MSpace',
                                                                   'Space'),
                                                                  'in')],
                                                        'defaults': {'space': ('MSpace',
                                                                               'Space',
                                                                               'kObject')},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns all the vertices below the base mesh that have been modified from their original position (the original position is specified by the position of the base mesh vertices). The two arrays will be of the same length upon return. Length 0 would suggest that there have been no edits from the original positions.',
                                                        'inArgs': ['vertexIds',
                                                                   'edits',
                                                                   'space'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'edits': ['&'],
                                                                           'space': [],
                                                                           'vertexIds': ['&']},
                                                        'types': {'edits': 'MVectorArray',
                                                                  'space': ('MSpace',
                                                                            'Space'),
                                                                  'vertexIds': 'MUint64Array'}}],
                          'vertexEditsSetAllNonBase': [{'argInfo': {'edits': {'doc': 'The offsets from the original positions ',
                                                                              'type': 'MVectorArray'},
                                                                    'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                              'type': ('MSpace',
                                                                                       'Space')},
                                                                    'vertexIds': {'doc': 'The names of the vertices ',
                                                                                  'type': 'MUint64Array'}},
                                                        'args': [('vertexIds',
                                                                  'MUint64Array',
                                                                  'in'),
                                                                 ('edits',
                                                                  'MVectorArray',
                                                                  'in'),
                                                                 ('space',
                                                                  ('MSpace',
                                                                   'Space'),
                                                                  'in')],
                                                        'defaults': {'space': ('MSpace',
                                                                               'Space',
                                                                               'kObject')},
                                                        'deprecated': False,
                                                        'doc': '\r\nGiven an array of vertex names and the offsets from their original positions, set the new vertex positions.',
                                                        'inArgs': ['vertexIds',
                                                                   'edits',
                                                                   'space'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'edits': ['const',
                                                                                     '&'],
                                                                           'space': [],
                                                                           'vertexIds': ['const',
                                                                                         '&']},
                                                        'types': {'edits': 'MVectorArray',
                                                                  'space': ('MSpace',
                                                                            'Space'),
                                                                  'vertexIds': 'MUint64Array'}}],
                          'vertexIdFromBaseVertexIndex': [{'argInfo': {'baseVertexIndex': {'doc': 'The index in the base mesh vertex array of this vertex ',
                                                                                           'type': 'int'}},
                                                           'args': [('baseVertexIndex',
                                                                     'int',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nVertices are named using 64-bit integers. The base mesh vertices will also have a simple 0, 1, 2, N-1 indices. Use this function to compute the proper 64-bit name using the 0, 1, 2, ... indices.',
                                                           'inArgs': ['baseVertexIndex'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The 64-bit name of the vertex',
                                                                          'qualifiers': [],
                                                                          'type': 'MUint64'},
                                                           'returnType': 'MUint64',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'baseVertexIndex': []},
                                                           'types': {'baseVertexIndex': 'int'}}],
                          'vertexIncidentEdges': [{'argInfo': {'edgeList': {'doc': 'The resulting list of incident edges',
                                                                            'type': 'MUint64Array'},
                                                               'vertexId': {'doc': 'The vertex 64-bit name ',
                                                                            'type': 'MUint64'}},
                                                   'args': [('vertexId',
                                                             'MUint64',
                                                             'in'),
                                                            ('edgeList',
                                                             'MUint64Array',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the list of incident edges as their 64-bit ids.',
                                                   'inArgs': ['vertexId'],
                                                   'outArgs': ['edgeList'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'edgeList': ['&'],
                                                                      'vertexId': []},
                                                   'types': {'edgeList': 'MUint64Array',
                                                             'vertexId': 'MUint64'}}],
                          'vertexIncidentPolygons': [{'argInfo': {'polyList': {'doc': 'The resulting list of incident polygons',
                                                                               'type': 'MUint64Array'},
                                                                  'vertexId': {'doc': 'The vertex 64-bit name ',
                                                                               'type': 'MUint64'}},
                                                      'args': [('vertexId',
                                                                'MUint64',
                                                                'in'),
                                                               ('polyList',
                                                                'MUint64Array',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn the list of incident polygons as their 64-bit ids.',
                                                      'inArgs': ['vertexId'],
                                                      'outArgs': ['polyList'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'polyList': ['&'],
                                                                         'vertexId': []},
                                                      'types': {'polyList': 'MUint64Array',
                                                                'vertexId': 'MUint64'}}],
                          'vertexIsBoundary': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name ',
                                                                         'type': 'MUint64'}},
                                                'args': [('vertexId',
                                                          'MUint64',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn true if the vertex is a boundary vertex.',
                                                'inArgs': ['vertexId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Whether the vertex is boundary or not',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'vertexId': []},
                                                'types': {'vertexId': 'MUint64'}}],
                          'vertexIsCreased': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name ',
                                                                        'type': 'MUint64'}},
                                               'args': [('vertexId',
                                                         'MUint64',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn true if the vertex is creased.',
                                               'inArgs': ['vertexId'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Whether the vertex is creased or not',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'vertexId': []},
                                               'types': {'vertexId': 'MUint64'}}],
                          'vertexIsValid': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name ',
                                                                      'type': 'MUint64'}},
                                             'args': [('vertexId',
                                                       'MUint64',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn true if the vertex is a valid vertex.',
                                             'inArgs': ['vertexId'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Whether the vertex is valid or not. Valid means that the vertex has been instantiated on the surface. Not all vertices at all levels exist by default. A vertex only exists if it was created at the time the subdiv was first created or if the subdiv was refined.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'vertexId': []},
                                             'types': {'vertexId': 'MUint64'}}],
                          'vertexNormal': [{'argInfo': {'normal': {'doc': 'The value of the normal',
                                                                   'type': 'MVector'},
                                                        'vertexId': {'doc': 'The vertex 64-bit ID. ',
                                                                     'type': 'MUint64'}},
                                            'args': [('vertexId',
                                                      'MUint64',
                                                      'in'),
                                                     ('normal',
                                                      'MVector',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the normal at the vertex',
                                            'inArgs': ['vertexId'],
                                            'outArgs': ['normal'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'normal': ['&'],
                                                               'vertexId': []},
                                            'types': {'normal': 'MVector',
                                                      'vertexId': 'MUint64'}}],
                          'vertexPositionGet': [{'argInfo': {'position': {'doc': 'The vertex position in the appropriate space ',
                                                                          'type': 'MPoint'},
                                                             'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                       'type': ('MSpace',
                                                                                'Space')},
                                                             'vertexId': {'doc': 'The name of the vertex ',
                                                                          'type': 'MUint64'}},
                                                 'args': [('vertexId',
                                                           'MUint64',
                                                           'in'),
                                                          ('position',
                                                           'MPoint',
                                                           'out'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in')],
                                                 'defaults': {'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject')},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the position of the vertex with a given name.',
                                                 'inArgs': ['vertexId',
                                                            'space'],
                                                 'outArgs': ['position'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'position': ['&'],
                                                                    'space': [],
                                                                    'vertexId': []},
                                                 'types': {'position': 'MPoint',
                                                           'space': ('MSpace',
                                                                     'Space'),
                                                           'vertexId': 'MUint64'}}],
                          'vertexPositionGetNoEdit': [{'argInfo': {'position': {'doc': 'The original position ',
                                                                                'type': 'MPoint'},
                                                                   'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                             'type': ('MSpace',
                                                                                      'Space')},
                                                                   'vertexId': {'doc': 'The name of the vertex ',
                                                                                'type': 'MUint64'}},
                                                       'args': [('vertexId',
                                                                 'MUint64',
                                                                 'in'),
                                                                ('position',
                                                                 'MPoint',
                                                                 'out'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kObject')},
                                                       'deprecated': False,
                                                       'doc': '\r\nWhat would the position of this vertex be if there were no edits; i.e., what was its original position.',
                                                       'inArgs': ['vertexId',
                                                                  'space'],
                                                       'outArgs': ['position'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'position': ['&'],
                                                                          'space': [],
                                                                          'vertexId': []},
                                                       'types': {'position': 'MPoint',
                                                                 'space': ('MSpace',
                                                                           'Space'),
                                                                 'vertexId': 'MUint64'}}],
                          'vertexPositionSet': [{'argInfo': {'position': {'doc': 'The new vertex position ',
                                                                          'type': 'MPoint'},
                                                             'space': {'doc': 'Specifies the coordinate system for this operation',
                                                                       'type': ('MSpace',
                                                                                'Space')},
                                                             'updateEdits': {'doc': 'If false, you will need to call updateSubdSurface() before any change would be applied. Further, you must set this to true before you start calling the same function on the vertices of the finer levels. ',
                                                                             'type': 'bool'},
                                                             'vertexId': {'doc': 'The vertex name ',
                                                                          'type': 'MUint64'}},
                                                 'args': [('vertexId',
                                                           'MUint64',
                                                           'in'),
                                                          ('position',
                                                           'MPoint',
                                                           'out'),
                                                          ('updateEdits',
                                                           'bool',
                                                           'in'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in')],
                                                 'defaults': {'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject')},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet the position of the vertex with a given name.',
                                                 'inArgs': ['vertexId',
                                                            'updateEdits',
                                                            'space'],
                                                 'outArgs': ['position'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'position': ['const',
                                                                                 '&'],
                                                                    'space': [],
                                                                    'updateEdits': [],
                                                                    'vertexId': []},
                                                 'types': {'position': 'MPoint',
                                                           'space': ('MSpace',
                                                                     'Space'),
                                                           'updateEdits': 'bool',
                                                           'vertexId': 'MUint64'}}],
                          'vertexSetCrease': [{'argInfo': {'creased': {'doc': 'Crease (true) or smooth (false)',
                                                                       'type': 'bool'},
                                                           'vertexId': {'doc': 'The 64-bit name of the vertex ',
                                                                        'type': 'MUint64'}},
                                               'args': [('vertexId',
                                                         'MUint64',
                                                         'in'),
                                                        ('creased',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nSet the particular vertex' crease state.",
                                               'inArgs': ['vertexId',
                                                          'creased'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'creased': [],
                                                                  'vertexId': []},
                                               'types': {'creased': 'bool',
                                                         'vertexId': 'MUint64'}}],
                          'vertexValence': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit id ',
                                                                      'type': 'MUint64'}},
                                             'args': [('vertexId',
                                                       'MUint64',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the valence (number of incident edges) of the given vertex.',
                                             'inArgs': ['vertexId'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The finest level in the hierarchy',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'vertexId': []},
                                             'types': {'vertexId': 'MUint64'}}]},
              'pymelEnums': {}},
  'MFnSubdData': {'enums': {},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nClass name. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'create': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nCreate a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Subdivision Surface.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The new MObject ',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nFunction set type. \n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MFn',
                                                                'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}]},
                  'pymelEnums': {}},
  'MFnSubdNames': {'enums': {},
                   'methods': {'base': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                            'type': 'MUint64'}},
                                         'args': [('id',
                                                   'MUint64',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nGiven a 64-bit name, return the base mesh face.',
                                         'inArgs': ['id'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': True,
                                         'typeQualifiers': {'id': []},
                                         'types': {'id': 'MUint64'}}],
                               'baseFaceId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                                  'type': 'MUint64'}},
                                               'args': [('id',
                                                         'MUint64',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGiven a 64-bit name, return the 64-bit name of the base face that is the parent of the given component.',
                                               'inArgs': ['id'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MUint64'},
                                               'returnType': 'MUint64',
                                               'static': True,
                                               'typeQualifiers': {'id': []},
                                               'types': {'id': 'MUint64'}}],
                               'baseFaceIdFromIndex': [{'argInfo': {'index': {'doc': 'The base face name as integer 0, ... N-1 ',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGiven the index of the base face (0, 1, ... N-1), return its 64-bit name.',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'MUint64'},
                                                        'returnType': 'MUint64',
                                                        'static': True,
                                                        'typeQualifiers': {'index': ['unsigned']},
                                                        'types': {'index': 'uint'}}],
                               'baseFaceIdFromLong': [{'argInfo': {'base': {'doc': 'The base face name as integer 0, ... N-1 ',
                                                                            'type': 'long'}},
                                                       'args': [('base',
                                                                 'long',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': True,
                                                       'doc': '\n This method is obsolete. \n',
                                                       'inArgs': ['base'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'MUint64'},
                                                       'returnType': 'MUint64',
                                                       'static': True,
                                                       'typeQualifiers': {'base': []},
                                                       'types': {'base': 'long'}}],
                               'baseFaceIndex': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                                     'type': 'MUint64'}},
                                                  'args': [('id',
                                                            'MUint64',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': True,
                                                  'doc': '\n This method is obsolete. \n',
                                                  'inArgs': ['id'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'long'},
                                                  'returnType': 'long',
                                                  'static': True,
                                                  'typeQualifiers': {'id': []},
                                                  'types': {'id': 'MUint64'}}],
                               'baseFaceIndexFromId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                                           'type': 'MUint64'}},
                                                        'args': [('id',
                                                                  'MUint64',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSame as base().',
                                                        'inArgs': ['id'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': True,
                                                        'typeQualifiers': {'id': []},
                                                        'types': {'id': 'MUint64'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'corner': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                              'type': 'MUint64'}},
                                           'args': [('id',
                                                     'MUint64',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\r\nOne of the 4 possible choices of the vertex or an edge once we're at the particular face.",
                                           'inArgs': ['id'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': True,
                                           'typeQualifiers': {'id': []},
                                           'types': {'id': 'MUint64'}}],
                               'first': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                             'type': 'MUint64'}},
                                          'args': [('id',
                                                    'MUint64',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGiven a 64-bit name, return the index of the first child of the base face.',
                                          'inArgs': ['id'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': True,
                                          'typeQualifiers': {'id': []},
                                          'types': {'id': 'MUint64'}}],
                               'fromMUint64': [{'argInfo': {'base': {'doc': 'Base face index ',
                                                                     'type': 'int'},
                                                            'corner': {'doc': 'Corner choice at the finest level ',
                                                                       'type': 'int'},
                                                            'first': {'doc': 'First level face choice ',
                                                                      'type': 'int'},
                                                            'id': {'doc': 'The 64-bit name of the component ',
                                                                   'type': 'MUint64'},
                                                            'level': {'doc': 'Level ',
                                                                      'type': 'int'},
                                                            'path': {'doc': 'Path to the finest level ',
                                                                     'type': 'int'}},
                                                'args': [('id',
                                                          'MUint64',
                                                          'in'),
                                                         ('base',
                                                          'int',
                                                          'out'),
                                                         ('first',
                                                          'int',
                                                          'out'),
                                                         ('level',
                                                          'int',
                                                          'out'),
                                                         ('path',
                                                          'int',
                                                          'out'),
                                                         ('corner',
                                                          'int',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGiven a 64-bit name, compute the base face, first level face index, level, path to the face and the corner choice at the finest face.',
                                                'inArgs': ['id'],
                                                'outArgs': ['base',
                                                            'first',
                                                            'level',
                                                            'path',
                                                            'corner'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'base': ['&'],
                                                                   'corner': ['&'],
                                                                   'first': ['&'],
                                                                   'id': [],
                                                                   'level': ['&'],
                                                                   'path': ['&']},
                                                'types': {'base': 'int',
                                                          'corner': 'int',
                                                          'first': 'int',
                                                          'id': 'MUint64',
                                                          'level': 'int',
                                                          'path': 'int'}}],
                               'fromSelectionIndices': [{'argInfo': {'firstIndex': {'doc': 'The first selection index ',
                                                                                    'type': 'uint'},
                                                                     'id': {'doc': 'The 64-bit name of the component ',
                                                                            'type': 'MUint64'},
                                                                     'secondIndex': {'doc': 'The second selection index ',
                                                                                     'type': 'uint'}},
                                                         'args': [('id',
                                                                   'MUint64',
                                                                   'in'),
                                                                  ('firstIndex',
                                                                   'uint',
                                                                   'in'),
                                                                  ('secondIndex',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGiven the two integers that would show as selection indices for the subd component, return the 64-bit name for that component.',
                                                         'inArgs': ['id',
                                                                    'firstIndex',
                                                                    'secondIndex'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': True,
                                                         'typeQualifiers': {'firstIndex': ['unsigned'],
                                                                            'id': ['&'],
                                                                            'secondIndex': ['unsigned']},
                                                         'types': {'firstIndex': 'uint',
                                                                   'id': 'MUint64',
                                                                   'secondIndex': 'uint'}}],
                               'level': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                             'type': 'MUint64'}},
                                          'args': [('id',
                                                    'MUint64',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGiven a 64-bit name, return the level of the component',
                                          'inArgs': ['id'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': True,
                                          'typeQualifiers': {'id': []},
                                          'types': {'id': 'MUint64'}}],
                               'levelOneFaceAsLong': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                                          'type': 'MUint64'}},
                                                       'args': [('id',
                                                                 'MUint64',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': True,
                                                       'doc': '\n This method is obsolete. \n',
                                                       'inArgs': ['id'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'long'},
                                                       'returnType': 'long',
                                                       'static': True,
                                                       'typeQualifiers': {'id': []},
                                                       'types': {'id': 'MUint64'}}],
                               'levelOneFaceId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                                      'type': 'MUint64'}},
                                                   'args': [('id',
                                                             'MUint64',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGiven a 64-bit name, return the level one face that is the parent for the given component.',
                                                   'inArgs': ['id'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MUint64'},
                                                   'returnType': 'MUint64',
                                                   'static': True,
                                                   'typeQualifiers': {'id': []},
                                                   'types': {'id': 'MUint64'}}],
                               'levelOneFaceIdFromIndex': [{'argInfo': {'index': {'doc': 'The 64-bit name of the component ',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nGiven a level 1 face name as integer, return it as a 64-bit name.',
                                                            'inArgs': ['index'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'MUint64'},
                                                            'returnType': 'MUint64',
                                                            'static': True,
                                                            'typeQualifiers': {'index': ['unsigned']},
                                                            'types': {'index': 'uint'}}],
                               'levelOneFaceIdFromLong': [{'argInfo': {'one': {'doc': 'The 64-bit name of the component ',
                                                                               'type': 'long'}},
                                                           'args': [('one',
                                                                     'long',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': True,
                                                           'doc': '\n This method is obsolete. \n',
                                                           'inArgs': ['one'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'MUint64'},
                                                           'returnType': 'MUint64',
                                                           'static': True,
                                                           'typeQualifiers': {'one': []},
                                                           'types': {'one': 'long'}}],
                               'levelOneFaceIndexFromId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                                               'type': 'MUint64'}},
                                                            'args': [('id',
                                                                      'MUint64',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nGiven a 64-bit name, return the level one mesh face as an integer, instead of 64-bit name.',
                                                            'inArgs': ['id'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'int'},
                                                            'returnType': 'int',
                                                            'static': True,
                                                            'typeQualifiers': {'id': []},
                                                            'types': {'id': 'MUint64'}}],
                               'nonBaseFaceEdges': [{'argInfo': {'edge1': {'doc': 'The first edge ',
                                                                           'type': 'MUint64'},
                                                                 'edge2': {'doc': 'The second edge ',
                                                                           'type': 'MUint64'},
                                                                 'edge3': {'doc': 'The third edge ',
                                                                           'type': 'MUint64'},
                                                                 'edge4': {'doc': 'The fourth edge',
                                                                           'type': 'MUint64'},
                                                                 'id': {'doc': 'The id of the face ',
                                                                        'type': 'MUint64'}},
                                                     'args': [('id',
                                                               'MUint64',
                                                               'in'),
                                                              ('edge1',
                                                               'MUint64',
                                                               'in'),
                                                              ('edge2',
                                                               'MUint64',
                                                               'in'),
                                                              ('edge3',
                                                               'MUint64',
                                                               'in'),
                                                              ('edge4',
                                                               'MUint64',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn the four edges on the given face. Note that the face should not be a base mesh face (the level > 0).',
                                                     'inArgs': ['id',
                                                                'edge1',
                                                                'edge2',
                                                                'edge3',
                                                                'edge4'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': True,
                                                     'typeQualifiers': {'edge1': ['&'],
                                                                        'edge2': ['&'],
                                                                        'edge3': ['&'],
                                                                        'edge4': ['&'],
                                                                        'id': []},
                                                     'types': {'edge1': 'MUint64',
                                                               'edge2': 'MUint64',
                                                               'edge3': 'MUint64',
                                                               'edge4': 'MUint64',
                                                               'id': 'MUint64'}}],
                               'nonBaseFaceVertices': [{'argInfo': {'id': {'doc': 'The id of the face ',
                                                                           'type': 'MUint64'},
                                                                    'vertex1': {'doc': 'The first vertex ',
                                                                                'type': 'MUint64'},
                                                                    'vertex2': {'doc': 'The second vertex ',
                                                                                'type': 'MUint64'},
                                                                    'vertex3': {'doc': 'The third vertex ',
                                                                                'type': 'MUint64'},
                                                                    'vertex4': {'doc': 'The fourth vertex',
                                                                                'type': 'MUint64'}},
                                                        'args': [('id',
                                                                  'MUint64',
                                                                  'in'),
                                                                 ('vertex1',
                                                                  'MUint64',
                                                                  'in'),
                                                                 ('vertex2',
                                                                  'MUint64',
                                                                  'in'),
                                                                 ('vertex3',
                                                                  'MUint64',
                                                                  'in'),
                                                                 ('vertex4',
                                                                  'MUint64',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturn the four vertices on the given face. Note that the face should not be a base mesh face (the level > 0).',
                                                        'inArgs': ['id',
                                                                   'vertex1',
                                                                   'vertex2',
                                                                   'vertex3',
                                                                   'vertex4'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'id': [],
                                                                           'vertex1': ['&'],
                                                                           'vertex2': ['&'],
                                                                           'vertex3': ['&'],
                                                                           'vertex4': ['&']},
                                                        'types': {'id': 'MUint64',
                                                                  'vertex1': 'MUint64',
                                                                  'vertex2': 'MUint64',
                                                                  'vertex3': 'MUint64',
                                                                  'vertex4': 'MUint64'}}],
                               'parentFaceId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                                    'type': 'MUint64'}},
                                                 'args': [('id',
                                                           'MUint64',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGiven a 64-bit name of the face, return its parent face id. Note that if the given face id is from a base face (ie. it is a face at level 0), the returned face will be exactly the same.',
                                                 'inArgs': ['id'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MUint64'},
                                                 'returnType': 'MUint64',
                                                 'static': True,
                                                 'typeQualifiers': {'id': []},
                                                 'types': {'id': 'MUint64'}}],
                               'path': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component ',
                                                            'type': 'MUint64'}},
                                         'args': [('id',
                                                   'MUint64',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nGiven a 64-bit name, return from level 1 face down to the face in question. Two bits per level for the four possible choices.',
                                         'inArgs': ['id'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': True,
                                         'typeQualifiers': {'id': []},
                                         'types': {'id': 'MUint64'}}],
                               'toMUint64': [{'argInfo': {'base': {'doc': 'Base face index ',
                                                                   'type': 'int'},
                                                          'corner': {'doc': 'Corner choice at the finest level ',
                                                                     'type': 'int'},
                                                          'first': {'doc': 'First level face choice ',
                                                                    'type': 'int'},
                                                          'id': {'doc': 'The 64-bit name of the component ',
                                                                 'type': 'MUint64'},
                                                          'level': {'doc': 'Level ',
                                                                    'type': 'int'},
                                                          'path': {'doc': 'Path to the finest level ',
                                                                   'type': 'int'}},
                                              'args': [('id',
                                                        'MUint64',
                                                        'in'),
                                                       ('base',
                                                        'int',
                                                        'in'),
                                                       ('first',
                                                        'int',
                                                        'in'),
                                                       ('level',
                                                        'int',
                                                        'in'),
                                                       ('path',
                                                        'int',
                                                        'in'),
                                                       ('corner',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nCompute the 64-bit name given the base face index, first level face index, level, path to the finest face and the corner choice. The corner is zero (ignore) if the component is to be the face.',
                                              'inArgs': ['id',
                                                         'base',
                                                         'first',
                                                         'level',
                                                         'path',
                                                         'corner'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'base': [],
                                                                 'corner': [],
                                                                 'first': [],
                                                                 'id': ['&'],
                                                                 'level': [],
                                                                 'path': []},
                                              'types': {'base': 'int',
                                                        'corner': 'int',
                                                        'first': 'int',
                                                        'id': 'MUint64',
                                                        'level': 'int',
                                                        'path': 'int'}}],
                               'toSelectionIndices': [{'argInfo': {'firstIndex': {'doc': 'The first selection index ',
                                                                                  'type': 'uint'},
                                                                   'id': {'doc': 'The 64-bit name of the component ',
                                                                          'type': 'MUint64'},
                                                                   'secondIndex': {'doc': 'The second selection index ',
                                                                                   'type': 'uint'}},
                                                       'args': [('id',
                                                                 'MUint64',
                                                                 'in'),
                                                                ('firstIndex',
                                                                 'uint',
                                                                 'out'),
                                                                ('secondIndex',
                                                                 'uint',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGiven a 64-bit name, return the two integers that will show up as selection indices for that subd component.',
                                                       'inArgs': ['id'],
                                                       'outArgs': ['firstIndex',
                                                                   'secondIndex'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': True,
                                                       'typeQualifiers': {'firstIndex': ['unsigned',
                                                                                         '&'],
                                                                          'id': [],
                                                                          'secondIndex': ['unsigned',
                                                                                          '&']},
                                                       'types': {'firstIndex': 'uint',
                                                                 'id': 'MUint64',
                                                                 'secondIndex': 'uint'}}]},
                   'pymelEnums': {}},
  'MFnToggleManip': {'enums': {},
                     'invertibles': [('setToggle', 'toggle'),
                                     ('setDirection', 'direction'),
                                     ('setStartPoint', 'startPoint'),
                                     ('setLength', 'length')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClass name. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'connectToTogglePlug': [{'argInfo': {'togglePlug': {'doc': 'the toggle plug',
                                                                                     'type': 'MPlug'}},
                                                          'args': [('togglePlug',
                                                                    'MPlug',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nConnect to the toggle plug. The data type corresponding to the togglePlug is a boolean value.',
                                                          'inArgs': ['togglePlug'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'togglePlug': ['&']},
                                                          'types': {'togglePlug': 'MPlug'}}],
                                 'create': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nCreates a new ToggleManip. This function set's object is set to be the new manipulator.",
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Newly created ToggleManip',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}},
                                            {'argInfo': {'manipName': {'doc': 'Name of the manip for UI purposes. ',
                                                                       'type': 'MString'},
                                                         'toggleName': {'doc': 'Label for the toggle value which appears in the feedback line. ',
                                                                        'type': 'MString'}},
                                             'args': [('manipName',
                                                       'MString',
                                                       'in'),
                                                      ('toggleName',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nCreates a new ToggleManip. This function set's object is set to be the new manipulator.",
                                             'inArgs': ['manipName',
                                                        'toggleName'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Newly created ToggleManip.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'manipName': ['const',
                                                                              '&'],
                                                                'toggleName': ['const',
                                                                               '&']},
                                             'types': {'manipName': 'MString',
                                                       'toggleName': 'MString'}}],
                                 'direction': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the direction.',
                                                'inArgs': [],
                                                'inverse': ('setDirection',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The direction',
                                                               'qualifiers': [],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                 'directionIndex': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns the index of the direction. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Direction index',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                 'length': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the length.',
                                             'inArgs': [],
                                             'inverse': ('setLength',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Length',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                 'lengthIndex': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the index of the length of the ToggleManip. The data type corresponding to this index is a double.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Length index',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'setDirection': [{'argInfo': {'direction': {'doc': 'the direction of the ToggleManip',
                                                                             'type': 'MVector'}},
                                                   'args': [('direction',
                                                             'MVector',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the direction of the ToggleManip.',
                                                   'inArgs': ['direction'],
                                                   'inverse': ('direction',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'direction': ['&']},
                                                   'types': {'direction': 'MVector'}}],
                                 'setLength': [{'argInfo': {'length': {'doc': 'the length of the ToggleManip',
                                                                       'type': 'double'}},
                                                'args': [('length',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the length of the ToggleManip.',
                                                'inArgs': ['length'],
                                                'inverse': ('length',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'length': []},
                                                'types': {'length': 'double'}}],
                                 'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the ToggleManip',
                                                                               'type': 'MPoint'}},
                                                    'args': [('startPoint',
                                                              'MPoint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the start point of the ToggleManip.',
                                                    'inArgs': ['startPoint'],
                                                    'inverse': ('startPoint',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'startPoint': ['&']},
                                                    'types': {'startPoint': 'MPoint'}}],
                                 'setToggle': [{'argInfo': {'toggle': {'doc': 'the toggle of the ToggleManip',
                                                                       'type': 'bool'}},
                                                'args': [('toggle',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the toggle of the ToggleManip.',
                                                'inArgs': ['toggle'],
                                                'inverse': ('toggle',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'toggle': []},
                                                'types': {'toggle': 'bool'}}],
                                 'startPoint': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the start point.',
                                                 'inArgs': [],
                                                 'inverse': ('setStartPoint',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The start point',
                                                                'qualifiers': [],
                                                                'type': 'MPoint'},
                                                 'returnType': 'MPoint',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                 'startPointIndex': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the index of the start point of the ToggleManip. The data type corresponding to this index is  MFnNumericData::k3Double .',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Start point index',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                 'toggle': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the toggle.',
                                             'inArgs': [],
                                             'inverse': ('setToggle',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Toggle',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                 'toggleIndex': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the index of the toggle of the ToggleManip. The data type corresponding to this index is a boolean.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Toggle index',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'direction': 'getDirection',
                                      'length': 'getLength',
                                      'startPoint': 'getStartPoint',
                                      'toggle': 'getToggle'}},
  'MFnToolContext': {'enums': {},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nClass name. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'name': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\nReturns the tool context's name.",
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Name string',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                                 'title': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\nReturns the tool context's title.",
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Title string',
                                                           'qualifiers': [],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnTransform': {'enums': {'LimitType': {'valueDocs': {'kRotateMaxX': '',
                                                         'kRotateMaxY': '',
                                                         'kRotateMaxZ': '',
                                                         'kRotateMinX': '',
                                                         'kRotateMinY': '',
                                                         'kRotateMinZ': '',
                                                         'kScaleMaxX': '',
                                                         'kScaleMaxY': '',
                                                         'kScaleMaxZ': '',
                                                         'kScaleMinX': '',
                                                         'kScaleMinY': '',
                                                         'kScaleMinZ': '',
                                                         'kShearMaxXY': '',
                                                         'kShearMaxXZ': '',
                                                         'kShearMaxYZ': '',
                                                         'kShearMinXY': '',
                                                         'kShearMinXZ': '',
                                                         'kShearMinYZ': '',
                                                         'kTranslateMaxX': '',
                                                         'kTranslateMaxY': '',
                                                         'kTranslateMaxZ': '',
                                                         'kTranslateMinX': '',
                                                         'kTranslateMinY': '',
                                                         'kTranslateMinZ': '',
                                                         'rotateMaxX': '',
                                                         'rotateMaxY': '',
                                                         'rotateMaxZ': '',
                                                         'rotateMinX': '',
                                                         'rotateMinY': '',
                                                         'rotateMinZ': '',
                                                         'scaleMaxX': '',
                                                         'scaleMaxY': '',
                                                         'scaleMaxZ': '',
                                                         'scaleMinX': '',
                                                         'scaleMinY': '',
                                                         'scaleMinZ': '',
                                                         'shearMaxXY': '',
                                                         'shearMaxXZ': '',
                                                         'shearMaxYZ': '',
                                                         'shearMinXY': '',
                                                         'shearMinXZ': '',
                                                         'shearMinYZ': '',
                                                         'translateMaxX': '',
                                                         'translateMaxY': '',
                                                         'translateMaxZ': '',
                                                         'translateMinX': '',
                                                         'translateMinY': '',
                                                         'translateMinZ': ''},
                                           'values': "Enum('LimitType', {'kScaleMinX': 0, 'kScaleMaxX': 1, 'kScaleMinY': 2, 'kScaleMaxY': 3, 'kScaleMinZ': 4, 'kScaleMaxZ': 5, 'kShearMinXY': 6, 'kShearMaxXY': 7, 'kShearMinXZ': 8, 'kShearMaxXZ': 9, 'kShearMinYZ': 10, 'kShearMaxYZ': 11, 'kRotateMinX': 12, 'kRotateMaxX': 13, 'kRotateMinY': 14, 'kRotateMaxY': 15, 'kRotateMinZ': 16, 'kRotateMaxZ': 17, 'kTranslateMinX': 18, 'kTranslateMaxX': 19, 'kTranslateMinY': 20, 'kTranslateMaxY': 21, 'kTranslateMinZ': 22, 'kTranslateMaxZ': 23})"}},
                   'invertibles': [('setRotatePivotTranslation',
                                    'rotatePivotTranslation'),
                                   ('setScalePivot', 'scalePivot'),
                                   ('setRotation', 'getRotation'),
                                   ('setTranslation', 'getTranslation'),
                                   ('setRotatePivot', 'rotatePivot'),
                                   ('setRestPosition', 'restPosition'),
                                   ('setScale', 'getScale'),
                                   ('setShear', 'getShear'),
                                   ('setRotateOrientation',
                                    'rotateOrientation'),
                                   ('setRotationOrder', 'rotationOrder'),
                                   ('setScalePivotTranslation',
                                    'scalePivotTranslation'),
                                   ('setRotationQuaternion',
                                    'getRotationQuaternion'),
                                   ('enableLimit', 'isLimited'),
                                   ('setLimit', 'limitValue'),
                                   ('set', 'transformation')],
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nClass name. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clearRestPosition': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nClear the saved rest position of this transform.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                               'create': [{'argInfo': {'parent': {'doc': 'the parent of the transform to be created ',
                                                                  'type': 'MObject'}},
                                           'args': [('parent',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {'parent': 'MObject::kNullObj'},
                                           'deprecated': False,
                                           'doc': '\r\nCreates a new transformation node. The new node is placed in the DAG.',
                                           'inArgs': ['parent'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The newly created transform node object',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'parent': []},
                                           'types': {'parent': 'MObject'}}],
                               'enableLimit': [{'argInfo': {'flag': {'doc': 'true or false to enable',
                                                                     'type': 'bool'},
                                                            'type': {'doc': 'type to apply a limit ',
                                                                     'type': ('MFnTransform',
                                                                              'LimitType')}},
                                                'args': [('type',
                                                          ('MFnTransform',
                                                           'LimitType'),
                                                          'in'),
                                                         ('flag',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nEnable or disable the limit value for the specified limit type.',
                                                'inArgs': ['type',
                                                           'flag'],
                                                'inverse': ('isLimited',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'flag': [],
                                                                   'type': []},
                                                'types': {'flag': 'bool',
                                                          'type': ('MFnTransform',
                                                                   'LimitType')}}],
                               'getRotation': [{'argInfo': {'quaternion': {'doc': 'the quaternion ',
                                                                           'type': 'MQuaternion'},
                                                            'space': {'doc': 'transform space in which to get the rotation',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('quaternion',
                                                          'MQuaternion',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kTransform')},
                                                'deprecated': False,
                                                'doc': '\r\nRetrieve the rotation component of this transformation as a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kWorld . All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                'inArgs': ['space'],
                                                'inverse': ('setRotation',
                                                            False),
                                                'outArgs': ['quaternion'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'quaternion': ['&'],
                                                                   'space': []},
                                                'types': {'quaternion': 'MQuaternion',
                                                          'space': ('MSpace',
                                                                    'Space')}},
                                               {'argInfo': {'rotation': {'doc': 'the euler rotation in radians',
                                                                         'type': 'MEulerRotation'}},
                                                'args': [('rotation',
                                                          'MEulerRotation',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRetrieve the rotation component of this transformation. The rotation is retrieved in  MSpace::kTransform  space.',
                                                'inArgs': [],
                                                'inverse': ('setRotation',
                                                            False),
                                                'outArgs': ['rotation'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'rotation': ['&']},
                                                'types': {'rotation': 'MEulerRotation'}},
                                               {'argInfo': {'order': {'doc': 'storage for the order of rotation',
                                                                      'type': ('MTransformationMatrix',
                                                                               'RotationOrder')},
                                                            'rotation': {'doc': 'storage for the rotation components ',
                                                                         'type': 'double__array3',
                                                                         'unitType': u'angular'}},
                                                'args': [('rotation',
                                                          'double__array3',
                                                          'out'),
                                                         ('order',
                                                          ('MTransformationMatrix',
                                                           'RotationOrder'),
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRetrieve the rotation component of this transformation. The rotation is retrieved in  MSpace::kTransform  space.',
                                                'inArgs': [],
                                                'inverse': ('setRotation',
                                                            False),
                                                'outArgs': ['rotation',
                                                            'order'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'order': ['&'],
                                                                   'rotation': []},
                                                'types': {'order': ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                          'rotation': 'double__array3'}},
                                               {'argInfo': {'order': {'doc': 'Storage for the order of rotation. ',
                                                                      'type': ('MTransformationMatrix',
                                                                               'RotationOrder')},
                                                            'rotation': {'doc': 'Storage for the rotation components. ',
                                                                         'type': 'double__array3'},
                                                            'space': {'doc': 'Ignored.',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('rotation',
                                                          'double__array3',
                                                          'out'),
                                                         ('order',
                                                          ('MTransformationMatrix',
                                                           'RotationOrder'),
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': True,
                                                'doc': '\n This method is obsolete.  [From Maya 85] \r\n',
                                                'inArgs': ['space'],
                                                'inverse': ('setRotation',
                                                            False),
                                                'outArgs': ['rotation',
                                                            'order'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'order': ['&'],
                                                                   'rotation': [],
                                                                   'space': []},
                                                'types': {'order': ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                          'rotation': 'double__array3',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                               'getRotationQuaternion': [{'argInfo': {'space': {'doc': 'transform space in which to get the rotation',
                                                                                'type': ('MSpace',
                                                                                         'Space')},
                                                                      'w': {'doc': 'storage for the w component of the quaternion ',
                                                                            'type': 'double'},
                                                                      'x': {'doc': 'storage for the x component of the quaternion ',
                                                                            'type': 'double'},
                                                                      'y': {'doc': 'storage for the y component of the quaternion ',
                                                                            'type': 'double'},
                                                                      'z': {'doc': 'storage for the z component of the quaternion ',
                                                                            'type': 'double'}},
                                                          'args': [('x',
                                                                    'double',
                                                                    'out'),
                                                                   ('y',
                                                                    'double',
                                                                    'out'),
                                                                   ('z',
                                                                    'double',
                                                                    'out'),
                                                                   ('w',
                                                                    'double',
                                                                    'out'),
                                                                   ('space',
                                                                    ('MSpace',
                                                                     'Space'),
                                                                    'in')],
                                                          'defaults': {'space': ('MSpace',
                                                                                 'Space',
                                                                                 'kTransform')},
                                                          'deprecated': False,
                                                          'doc': '\r\nRetrieve the rotation component of this transformation as a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kWorld . All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                          'inArgs': ['space'],
                                                          'inverse': ('setRotationQuaternion',
                                                                      False),
                                                          'outArgs': ['x',
                                                                      'y',
                                                                      'z',
                                                                      'w'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'space': [],
                                                                             'w': ['&'],
                                                                             'x': ['&'],
                                                                             'y': ['&'],
                                                                             'z': ['&']},
                                                          'types': {'space': ('MSpace',
                                                                              'Space'),
                                                                    'w': 'double',
                                                                    'x': 'double',
                                                                    'y': 'double',
                                                                    'z': 'double'}}],
                               'getScale': [{'argInfo': {'scale': {'doc': 'Storage for the scale of the transform',
                                                                   'type': 'double__array3'}},
                                             'args': [('scale',
                                                       'double__array3',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nRetrieve the scaling component of this transformation.',
                                             'inArgs': [],
                                             'inverse': ('setScale',
                                                         False),
                                             'outArgs': ['scale'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'scale': []},
                                             'types': {'scale': 'double__array3'}}],
                               'getShear': [{'argInfo': {'shear': {'doc': 'Storage for the shear of the transform',
                                                                   'type': 'double__array3'}},
                                             'args': [('shear',
                                                       'double__array3',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nRetrieve the shearing component of this transformation.',
                                             'inArgs': [],
                                             'inverse': ('setShear',
                                                         False),
                                             'outArgs': ['shear'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'shear': []},
                                             'types': {'shear': 'double__array3'}}],
                               'getTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to get the translation ',
                                                                         'type': ('MSpace',
                                                                                  'Space')}},
                                                   'args': [('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieve the translation component of this transformation in centimeters.',
                                                   'inArgs': ['space'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Translation vector in centimeters',
                                                                  'qualifiers': [],
                                                                  'type': 'MVector',
                                                                  'unitType': u'linear'},
                                                   'returnType': 'MVector',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'space': []},
                                                   'types': {'space': ('MSpace',
                                                                       'Space')}}],
                               'isLimited': [{'argInfo': {'type': {'doc': 'type to query limit ',
                                                                   'type': ('MFnTransform',
                                                                            'LimitType')}},
                                              'args': [('type',
                                                        ('MFnTransform',
                                                         'LimitType'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermine if the specified limit attribute is enabled or disabled.',
                                              'inArgs': ['type'],
                                              'inverse': ('enableLimit',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'True or false, true means the limit is enabled.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'type': []},
                                              'types': {'type': ('MFnTransform',
                                                                 'LimitType')}}],
                               'limitValue': [{'argInfo': {'type': {'doc': 'type to query limit ',
                                                                    'type': ('MFnTransform',
                                                                             'LimitType')}},
                                               'args': [('type',
                                                         ('MFnTransform',
                                                          'LimitType'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermine the current value of the specified limit.',
                                               'inArgs': ['type'],
                                               'inverse': ('setLimit',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Current value of the specified limit as internal unit.',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'type': []},
                                               'types': {'type': ('MFnTransform',
                                                                  'LimitType')}}],
                               'resetFromRestPosition': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReset the transform to its rest position.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                               'restPosition': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nRetrieve the saved rest position of this transform.',
                                                 'inArgs': [],
                                                 'inverse': ('setRestPosition',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The transformation matrix equivalent to the transform\'s rest position. This rest position will be identity unless the "setRestPosition" method has been called.',
                                                                'qualifiers': [],
                                                                'type': 'MTransformationMatrix'},
                                                 'returnType': 'MTransformationMatrix',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                               'rotateBy': [{'argInfo': {'quaternion': {'doc': 'the quaternion ',
                                                                        'type': 'MQuaternion'},
                                                         'space': {'doc': 'transform space in which to perform the rotation',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('quaternion',
                                                       'MQuaternion',
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kTransform')},
                                             'deprecated': False,
                                             'doc': '\r\nRelatively change the rotation of this transformation using a quaternion.',
                                             'inArgs': ['quaternion',
                                                        'space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'quaternion': ['const',
                                                                               '&'],
                                                                'space': []},
                                             'types': {'quaternion': 'MQuaternion',
                                                       'space': ('MSpace',
                                                                 'Space')}},
                                            {'argInfo': {'rotation': {'doc': 'the euler rotation ',
                                                                      'type': 'MEulerRotation'},
                                                         'space': {'doc': 'transform space in which to perform the rotation',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('rotation',
                                                       'MEulerRotation',
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kTransform')},
                                             'deprecated': False,
                                             'doc': '\r\nRelatively change the rotation component of this transformation.',
                                             'inArgs': ['rotation',
                                                        'space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'rotation': ['const',
                                                                             '&'],
                                                                'space': []},
                                             'types': {'rotation': 'MEulerRotation',
                                                       'space': ('MSpace',
                                                                 'Space')}},
                                            {'argInfo': {'order': {'doc': 'the order in which to apply the rotations ',
                                                                   'type': ('MTransformationMatrix',
                                                                            'RotationOrder')},
                                                         'rotation': {'doc': 'the relative rotation components ',
                                                                      'type': 'double__array3'},
                                                         'space': {'doc': 'transform space in which to perform the rotation',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('rotation',
                                                       'double__array3',
                                                       'in'),
                                                      ('order',
                                                       ('MTransformationMatrix',
                                                        'RotationOrder'),
                                                       'in'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kTransform')},
                                             'deprecated': False,
                                             'doc': '\r\nRelatively change the rotation component of this transformation.',
                                             'inArgs': ['rotation',
                                                        'order',
                                                        'space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'order': [],
                                                                'rotation': ['const'],
                                                                'space': []},
                                             'types': {'order': ('MTransformationMatrix',
                                                                 'RotationOrder'),
                                                       'rotation': 'double__array3',
                                                       'space': ('MSpace',
                                                                 'Space')}}],
                               'rotateByQuaternion': [{'argInfo': {'space': {'doc': 'transform space in which to perform the rotation',
                                                                             'type': ('MSpace',
                                                                                      'Space')},
                                                                   'w': {'doc': 'w component of the quaternion ',
                                                                         'type': 'double'},
                                                                   'x': {'doc': 'x component of the quaternion ',
                                                                         'type': 'double'},
                                                                   'y': {'doc': 'y component of the quaternion ',
                                                                         'type': 'double'},
                                                                   'z': {'doc': 'z component of the quaternion ',
                                                                         'type': 'double'}},
                                                       'args': [('x',
                                                                 'double',
                                                                 'in'),
                                                                ('y',
                                                                 'double',
                                                                 'in'),
                                                                ('z',
                                                                 'double',
                                                                 'in'),
                                                                ('w',
                                                                 'double',
                                                                 'in'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in')],
                                                       'defaults': {'space': ('MSpace',
                                                                              'Space',
                                                                              'kTransform')},
                                                       'deprecated': False,
                                                       'doc': '\r\nRelatively change the rotation of this transformation using a quaternion.',
                                                       'inArgs': ['x',
                                                                  'y',
                                                                  'z',
                                                                  'w',
                                                                  'space'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'space': [],
                                                                          'w': [],
                                                                          'x': [],
                                                                          'y': [],
                                                                          'z': []},
                                                       'types': {'space': ('MSpace',
                                                                           'Space'),
                                                                 'w': 'double',
                                                                 'x': 'double',
                                                                 'y': 'double',
                                                                 'z': 'double'}}],
                               'rotateOrientation': [{'argInfo': {'space': {'doc': 'space in which to get the rotation orientation. This argument is currently ignored. The rotateOrientation is always returned in local space: MSpace::kTransform. ',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the rotation used to orient the local rotation space. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .',
                                                      'inArgs': ['space'],
                                                      'inverse': ('setRotateOrientation',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Rotateorientation',
                                                                     'qualifiers': [],
                                                                     'type': 'MQuaternion'},
                                                      'returnType': 'MQuaternion',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'space': []},
                                                      'types': {'space': ('MSpace',
                                                                          'Space')}}],
                               'rotatePivot': [{'argInfo': {'space': {'doc': 'space in which to get the pivot ',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the pivot about which the rotation is applied.',
                                                'inArgs': ['space'],
                                                'inverse': ('setRotatePivot',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Rotation pivot point in centimeters',
                                                               'qualifiers': [],
                                                               'type': 'MPoint'},
                                                'returnType': 'MPoint',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'space': []},
                                                'types': {'space': ('MSpace',
                                                                    'Space')}}],
                               'rotatePivotTranslation': [{'argInfo': {'space': {'doc': 'space in which to get the pivot translation ',
                                                                                 'type': ('MSpace',
                                                                                          'Space')}},
                                                           'args': [('space',
                                                                     ('MSpace',
                                                                      'Space'),
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturn the rotate pivot translation in centimeters. This component is used internally by maya when the user moves the rotate pivot, or when the balance flag is set to true in the MfnTransform::setRotatePivot method. It serves as a compensation that allows existing transformations to be preserved. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .',
                                                           'inArgs': ['space'],
                                                           'inverse': ('setRotatePivotTranslation',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Scale pivot translation in centimeters',
                                                                          'qualifiers': [],
                                                                          'type': 'MVector',
                                                                          'unitType': u'linear'},
                                                           'returnType': 'MVector',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'space': []},
                                                           'types': {'space': ('MSpace',
                                                                               'Space')}}],
                               'rotationOrder': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the rotation order for the transform matrix - the order in which the Euler angles are applied to create the end rotation.',
                                                  'inArgs': [],
                                                  'inverse': ('setRotationOrder',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'rotation order',
                                                                 'qualifiers': [],
                                                                 'type': ('MTransformationMatrix',
                                                                          'RotationOrder')},
                                                  'returnType': ('MTransformationMatrix',
                                                                 'RotationOrder'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                               'scaleBy': [{'argInfo': {'scale': {'doc': 'The ratio by which to scale the transform',
                                                                  'type': 'double__array3'}},
                                            'args': [('scale',
                                                      'double__array3',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nRelatively scale this transformation.',
                                            'inArgs': ['scale'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'scale': ['const']},
                                            'types': {'scale': 'double__array3'}}],
                               'scalePivot': [{'argInfo': {'space': {'doc': 'space in which to get the pivot ',
                                                                     'type': ('MSpace',
                                                                              'Space')}},
                                               'args': [('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the pivot around which the scale is applied. The pivot will be in centimeters.',
                                               'inArgs': ['space'],
                                               'inverse': ('setScalePivot',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Scale pivot point in centimeters',
                                                              'qualifiers': [],
                                                              'type': 'MPoint'},
                                               'returnType': 'MPoint',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'space': []},
                                               'types': {'space': ('MSpace',
                                                                   'Space')}}],
                               'scalePivotTranslation': [{'argInfo': {'space': {'doc': 'space in which to get the scale pivot translation ',
                                                                                'type': ('MSpace',
                                                                                         'Space')}},
                                                          'args': [('space',
                                                                    ('MSpace',
                                                                     'Space'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns the scale pivot translation in centimeters. This component is used as a compensation by maya when the user moves the scale pivot, or when the balance flag is set to true in the MfnTransform::setScalePivot method. The scale pivot translation serves as a compensation that allows existing transformations to be preserved when the scale pivot is modified. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .',
                                                          'inArgs': ['space'],
                                                          'inverse': ('setScalePivotTranslation',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Scale pivot translation in centimeters',
                                                                         'qualifiers': [],
                                                                         'type': 'MVector',
                                                                         'unitType': u'linear'},
                                                          'returnType': 'MVector',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'space': []},
                                                          'types': {'space': ('MSpace',
                                                                              'Space')}}],
                               'set': [{'argInfo': {'transform': {'doc': 'the matrix to copy',
                                                                  'type': 'MTransformationMatrix'}},
                                        'args': [('transform',
                                                  'MTransformationMatrix',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nChange this transform to equal the given matrix.',
                                        'inArgs': ['transform'],
                                        'inverse': ('transformation',
                                                    True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'transform': ['const',
                                                                         '&']},
                                        'types': {'transform': 'MTransformationMatrix'}}],
                               'setLimit': [{'argInfo': {'type': {'doc': 'type to apply a limit ',
                                                                  'type': ('MFnTransform',
                                                                           'LimitType')},
                                                         'value': {'doc': 'new limit value as internal unit',
                                                                   'type': 'double',
                                                                   'unitType': u'linear'}},
                                             'args': [('type',
                                                       ('MFnTransform',
                                                        'LimitType'),
                                                       'in'),
                                                      ('value',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nChange the limit value for the specified limit type, and automatically enable the limit to be true.',
                                             'inArgs': ['type', 'value'],
                                             'inverse': ('limitValue',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'type': [],
                                                                'value': []},
                                             'types': {'type': ('MFnTransform',
                                                                'LimitType'),
                                                       'value': 'double'}}],
                               'setRestPosition': [{'argInfo': {'matrix': {'doc': 'the new rest position for this transform',
                                                                           'type': 'MTransformationMatrix'}},
                                                    'args': [('matrix',
                                                              'MTransformationMatrix',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nChange the saved rest position of this transform. The rest position is not used internally by Maya. It is exclusively for use from the API as a temporary cache, which can be set and restored within a single Maya session. Note that the rest position is not saved with the scene.',
                                                    'inArgs': ['matrix'],
                                                    'inverse': ('restPosition',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'matrix': ['const',
                                                                                  '&']},
                                                    'types': {'matrix': 'MTransformationMatrix'}}],
                               'setRotateOrientation': [{'argInfo': {'balance': {'doc': 'whether to balance the overall transformation matrix',
                                                                                 'type': 'bool'},
                                                                     'quat': {'doc': 'new orientation as a quaternion ',
                                                                              'type': 'MQuaternion'},
                                                                     'space': {'doc': 'transform space in which to set the rotateOrientation. This argument is currently ignored. The rotateOrientation always set in local space: MSpace::kTransform. ',
                                                                               'type': ('MSpace',
                                                                                        'Space')}},
                                                         'args': [('quat',
                                                                   'MQuaternion',
                                                                   'in'),
                                                                  ('space',
                                                                   ('MSpace',
                                                                    'Space'),
                                                                   'in'),
                                                                  ('balance',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {'balance': True},
                                                         'deprecated': False,
                                                         'doc': '\r\nSet the rotation used to orient the local rotation space. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .',
                                                         'inArgs': ['quat',
                                                                    'space',
                                                                    'balance'],
                                                         'inverse': ('rotateOrientation',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'balance': [],
                                                                            'quat': ['const',
                                                                                     '&'],
                                                                            'space': []},
                                                         'types': {'balance': 'bool',
                                                                   'quat': 'MQuaternion',
                                                                   'space': ('MSpace',
                                                                             'Space')}}],
                               'setRotatePivot': [{'argInfo': {'balance': {'doc': 'whether to balance the matrix',
                                                                           'type': 'bool'},
                                                               'point': {'doc': 'new rotation pivot in centimeters ',
                                                                         'type': 'MPoint'},
                                                               'space': {'doc': 'transform space in which to set the pivot ',
                                                                         'type': ('MSpace',
                                                                                  'Space')}},
                                                   'args': [('point',
                                                             'MPoint',
                                                             'in'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in'),
                                                            ('balance',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'balance': True},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the rotate pivot in centimeters about which rotation is applied.',
                                                   'inArgs': ['point',
                                                              'space',
                                                              'balance'],
                                                   'inverse': ('rotatePivot',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'balance': [],
                                                                      'point': ['const',
                                                                                '&'],
                                                                      'space': []},
                                                   'types': {'balance': 'bool',
                                                             'point': 'MPoint',
                                                             'space': ('MSpace',
                                                                       'Space')}}],
                               'setRotatePivotTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to set the rotation pivot translation',
                                                                                    'type': ('MSpace',
                                                                                             'Space')},
                                                                          'vector': {'doc': 'new rotation pivot translation in centimeters ',
                                                                                     'type': 'MVector',
                                                                                     'unitType': u'linear'}},
                                                              'args': [('vector',
                                                                        'MVector',
                                                                        'in'),
                                                                       ('space',
                                                                        ('MSpace',
                                                                         'Space'),
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nSet the rotate pivot translation in centimeters. This component is used internally by maya when the user moves the rotate pivot, or when the balance flag is true in the  MFnTransform::setRotatePivot  method. It serves as a compensation that allows existing transformations to be preserved when the rotate pivot is modified. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .',
                                                              'inArgs': ['vector',
                                                                         'space'],
                                                              'inverse': ('rotatePivotTranslation',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'space': [],
                                                                                 'vector': ['const',
                                                                                            '&']},
                                                              'types': {'space': ('MSpace',
                                                                                  'Space'),
                                                                        'vector': 'MVector'}}],
                               'setRotation': [{'argInfo': {'quaternion': {'doc': 'the quaternion ',
                                                                           'type': 'MQuaternion'},
                                                            'space': {'doc': 'transform space in which to perform the rotation',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('quaternion',
                                                          'MQuaternion',
                                                          'in'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kTransform')},
                                                'deprecated': False,
                                                'doc': '\r\nChange the rotation component of this transformation using a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kWorld . All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                'inArgs': ['quaternion',
                                                           'space'],
                                                'inverse': ('getRotation',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'quaternion': ['const',
                                                                                  '&'],
                                                                   'space': []},
                                                'types': {'quaternion': 'MQuaternion',
                                                          'space': ('MSpace',
                                                                    'Space')}},
                                               {'argInfo': {'rotation': {'doc': 'the euler rotation',
                                                                         'type': 'MEulerRotation'}},
                                                'args': [('rotation',
                                                          'MEulerRotation',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nChange the rotation component of this transformation. The rotation is set in  MSpace::kTransform  space.',
                                                'inArgs': ['rotation'],
                                                'inverse': ('getRotation',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'rotation': ['const',
                                                                                '&']},
                                                'types': {'rotation': 'MEulerRotation'}},
                                               {'argInfo': {'order': {'doc': 'the order in which to apply the rotations',
                                                                      'type': ('MTransformationMatrix',
                                                                               'RotationOrder')},
                                                            'rotation': {'doc': 'the new rotation components ',
                                                                         'type': 'double__array3',
                                                                         'unitType': u'angular'}},
                                                'args': [('rotation',
                                                          'double__array3',
                                                          'in'),
                                                         ('order',
                                                          ('MTransformationMatrix',
                                                           'RotationOrder'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nChange the rotation component of this transformation. The rotation is set in  MSpace::kTransform  space.',
                                                'inArgs': ['rotation',
                                                           'order'],
                                                'inverse': ('getRotation',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'order': [],
                                                                   'rotation': ['const']},
                                                'types': {'order': ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                          'rotation': 'double__array3'}},
                                               {'argInfo': {'order': {'doc': 'The order in which to apply the rotations. ',
                                                                      'type': ('MTransformationMatrix',
                                                                               'RotationOrder')},
                                                            'rotation': {'doc': 'The new rotation components. ',
                                                                         'type': 'double__array3'},
                                                            'space': {'doc': 'Ignored.',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('rotation',
                                                          'double__array3',
                                                          'in'),
                                                         ('order',
                                                          ('MTransformationMatrix',
                                                           'RotationOrder'),
                                                          'in'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': True,
                                                'doc': '\n This method is obsolete.  [From Maya 85] \r\n',
                                                'inArgs': ['rotation',
                                                           'order',
                                                           'space'],
                                                'inverse': ('getRotation',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'order': [],
                                                                   'rotation': ['const'],
                                                                   'space': []},
                                                'types': {'order': ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                          'rotation': 'double__array3',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                               'setRotationOrder': [{'argInfo': {'order': {'doc': 'the order in which to apply rotations ',
                                                                           'type': ('MTransformationMatrix',
                                                                                    'RotationOrder')},
                                                                 'reorder': {'doc': 'flag indicating whether or not rotations should be reordered.',
                                                                             'type': 'bool'}},
                                                     'args': [('order',
                                                               ('MTransformationMatrix',
                                                                'RotationOrder'),
                                                               'in'),
                                                              ('reorder',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nChange the rotation order for the transform - the order in which the Euler angles are applied to create the end rotation.',
                                                     'inArgs': ['order',
                                                                'reorder'],
                                                     'inverse': ('rotationOrder',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'order': [],
                                                                        'reorder': []},
                                                     'types': {'order': ('MTransformationMatrix',
                                                                         'RotationOrder'),
                                                               'reorder': 'bool'}}],
                               'setRotationQuaternion': [{'argInfo': {'space': {'doc': 'transform space in which to perform the rotation',
                                                                                'type': ('MSpace',
                                                                                         'Space')},
                                                                      'w': {'doc': 'w component of the quaternion ',
                                                                            'type': 'double'},
                                                                      'x': {'doc': 'x component of the quaternion ',
                                                                            'type': 'double'},
                                                                      'y': {'doc': 'y component of the quaternion ',
                                                                            'type': 'double'},
                                                                      'z': {'doc': 'z component of the quaternion ',
                                                                            'type': 'double'}},
                                                          'args': [('x',
                                                                    'double',
                                                                    'in'),
                                                                   ('y',
                                                                    'double',
                                                                    'in'),
                                                                   ('z',
                                                                    'double',
                                                                    'in'),
                                                                   ('w',
                                                                    'double',
                                                                    'in'),
                                                                   ('space',
                                                                    ('MSpace',
                                                                     'Space'),
                                                                    'in')],
                                                          'defaults': {'space': ('MSpace',
                                                                                 'Space',
                                                                                 'kTransform')},
                                                          'deprecated': False,
                                                          'doc': '\r\nChange the rotation component of this transformation using a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kWorld . All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                          'inArgs': ['x',
                                                                     'y',
                                                                     'z',
                                                                     'w',
                                                                     'space'],
                                                          'inverse': ('getRotationQuaternion',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'space': [],
                                                                             'w': [],
                                                                             'x': [],
                                                                             'y': [],
                                                                             'z': []},
                                                          'types': {'space': ('MSpace',
                                                                              'Space'),
                                                                    'w': 'double',
                                                                    'x': 'double',
                                                                    'y': 'double',
                                                                    'z': 'double'}}],
                               'setScale': [{'argInfo': {'scale': {'doc': 'The scale of the transform',
                                                                   'type': 'double__array3'}},
                                             'args': [('scale',
                                                       'double__array3',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the scaling component of this transformation.',
                                             'inArgs': ['scale'],
                                             'inverse': ('getScale',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'scale': ['const']},
                                             'types': {'scale': 'double__array3'}}],
                               'setScalePivot': [{'argInfo': {'balance': {'doc': 'whether to balance the matrix',
                                                                          'type': 'bool'},
                                                              'point': {'doc': 'new scale pivot in centimeters ',
                                                                        'type': 'MPoint'},
                                                              'space': {'doc': 'transform space in which to set the scale pivot ',
                                                                        'type': ('MSpace',
                                                                                 'Space')}},
                                                  'args': [('point',
                                                            'MPoint',
                                                            'in'),
                                                           ('space',
                                                            ('MSpace',
                                                             'Space'),
                                                            'in'),
                                                           ('balance',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'balance': True},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the pivot around which the scale is applied in centimeters.',
                                                  'inArgs': ['point',
                                                             'space',
                                                             'balance'],
                                                  'inverse': ('scalePivot',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'balance': [],
                                                                     'point': ['const',
                                                                               '&'],
                                                                     'space': []},
                                                  'types': {'balance': 'bool',
                                                            'point': 'MPoint',
                                                            'space': ('MSpace',
                                                                      'Space')}}],
                               'setScalePivotTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to set the scale translation',
                                                                                   'type': ('MSpace',
                                                                                            'Space')},
                                                                         'vector': {'doc': 'new scale pivot translation in centimeters ',
                                                                                    'type': 'MVector',
                                                                                    'unitType': u'linear'}},
                                                             'args': [('vector',
                                                                       'MVector',
                                                                       'in'),
                                                                      ('space',
                                                                       ('MSpace',
                                                                        'Space'),
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSet the scale pivot translation in centimeters. This component is used internally by maya when the user moves the scale pivot, or when the balance flag is set to true in the MfnTransform::setScalePivot method. It serves as a compensation that allows existing transformations to be preserved when the scale pivot is modified. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .',
                                                             'inArgs': ['vector',
                                                                        'space'],
                                                             'inverse': ('scalePivotTranslation',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'space': [],
                                                                                'vector': ['const',
                                                                                           '&']},
                                                             'types': {'space': ('MSpace',
                                                                                 'Space'),
                                                                       'vector': 'MVector'}}],
                               'setShear': [{'argInfo': {'shear': {'doc': 'The shear of the transform',
                                                                   'type': 'double__array3'}},
                                             'args': [('shear',
                                                       'double__array3',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the shearing component of this transformation.',
                                             'inArgs': ['shear'],
                                             'inverse': ('getShear',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'shear': ['const']},
                                             'types': {'shear': 'double__array3'}}],
                               'setTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to perform the translation',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'vector': {'doc': 'the new translation vector in centimeters ',
                                                                          'type': 'MVector',
                                                                          'unitType': u'linear'}},
                                                   'args': [('vector',
                                                             'MVector',
                                                             'in'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nChange the translation component of this transformation.',
                                                   'inArgs': ['vector',
                                                              'space'],
                                                   'inverse': ('translation',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'space': [],
                                                                      'vector': ['const',
                                                                                 '&']},
                                                   'types': {'space': ('MSpace',
                                                                       'Space'),
                                                             'vector': 'MVector'}}],
                               'shearBy': [{'argInfo': {'shear': {'doc': 'The ratio by which to shear the transform',
                                                                  'type': 'double__array3'}},
                                            'args': [('shear',
                                                      'double__array3',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nRelatively shear this transformation.',
                                            'inArgs': ['shear'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'shear': ['const']},
                                            'types': {'shear': 'double__array3'}}],
                               'transformation': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieve the transformation matrix represented by this transform.',
                                                   'inArgs': [],
                                                   'inverse': ('set',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The transformation matrix represented by this transform.',
                                                                  'qualifiers': [],
                                                                  'type': 'MTransformationMatrix'},
                                                   'returnType': 'MTransformationMatrix',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                               'translateBy': [{'argInfo': {'space': {'doc': 'transform space in which to perform the translation',
                                                                      'type': ('MSpace',
                                                                               'Space')},
                                                            'vector': {'doc': 'the relative translation vector ',
                                                                       'type': 'MVector',
                                                                       'unitType': u'linear'}},
                                                'args': [('vector',
                                                          'MVector',
                                                          'in'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRelatively change the translation component of this transformation.',
                                                'inArgs': ['vector',
                                                           'space'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'space': [],
                                                                   'vector': ['const',
                                                                              '&']},
                                                'types': {'space': ('MSpace',
                                                                    'Space'),
                                                          'vector': 'MVector'}}],
                               'translation': [{'argInfo': {'space': {'doc': 'Transform space in which to get the translation. ',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': True,
                                                'doc': '\n This method is obsolete.  [From Maya 85] \r\n',
                                                'inArgs': ['space'],
                                                'inverse': ('setTranslation',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Translation vector in centimeters',
                                                               'qualifiers': [],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'space': []},
                                                'types': {'space': ('MSpace',
                                                                    'Space')}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nFunction set type. \r\n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {'LimitType': "Enum('LimitType', [('scaleMinX', 0), ('kScaleMinX', 0), ('scaleMaxX', 1), ('kScaleMaxX', 1), ('scaleMinY', 2), ('kScaleMinY', 2), ('scaleMaxY', 3), ('kScaleMaxY', 3), ('scaleMinZ', 4), ('kScaleMinZ', 4), ('scaleMaxZ', 5), ('kScaleMaxZ', 5), ('shearMinXY', 6), ('kShearMinXY', 6), ('shearMaxXY', 7), ('kShearMaxXY', 7), ('shearMinXZ', 8), ('kShearMinXZ', 8), ('shearMaxXZ', 9), ('kShearMaxXZ', 9), ('shearMinYZ', 10), ('kShearMinYZ', 10), ('shearMaxYZ', 11), ('kShearMaxYZ', 11), ('rotateMinX', 12), ('kRotateMinX', 12), ('rotateMaxX', 13), ('kRotateMaxX', 13), ('rotateMinY', 14), ('kRotateMinY', 14), ('rotateMaxY', 15), ('kRotateMaxY', 15), ('rotateMinZ', 16), ('kRotateMinZ', 16), ('rotateMaxZ', 17), ('kRotateMaxZ', 17), ('translateMinX', 18), ('kTranslateMinX', 18), ('translateMaxX', 19), ('kTranslateMaxX', 19), ('translateMinY', 20), ('kTranslateMinY', 20), ('translateMaxY', 21), ('kTranslateMaxY', 21), ('translateMinZ', 22), ('kTranslateMinZ', 22), ('translateMaxZ', 23), ('kTranslateMaxZ', 23)], multiKeys=True)"},
                   'pymelMethods': {'restPosition': 'getRestPosition',
                                    'rotateOrientation': 'getRotateOrientation',
                                    'rotatePivot': 'getRotatePivot',
                                    'rotatePivotTranslation': 'getRotatePivotTranslation',
                                    'rotationOrder': 'getRotationOrder',
                                    'scalePivot': 'getScalePivot',
                                    'scalePivotTranslation': 'getScalePivotTranslation',
                                    'translation': 'getTranslation'}},
  'MFnTripleIndexedComponent': {'enums': {},
                                'invertibles': [('setCompleteData',
                                                 'getCompleteData')],
                                'methods': {'addElement': [{'argInfo': {'sIndex': {'doc': 'the s index to add ',
                                                                                   'type': 'int'},
                                                                        'tIndex': {'doc': 'the t index to add ',
                                                                                   'type': 'int'},
                                                                        'uIndex': {'doc': 'the u index to add',
                                                                                   'type': 'int'}},
                                                            'args': [('sIndex',
                                                                      'int',
                                                                      'in'),
                                                                     ('tIndex',
                                                                      'int',
                                                                      'in'),
                                                                     ('uIndex',
                                                                      'int',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nAdd the specified element to the component.',
                                                            'inArgs': ['sIndex',
                                                                       'tIndex',
                                                                       'uIndex'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'sIndex': [],
                                                                               'tIndex': [],
                                                                               'uIndex': []},
                                                            'types': {'sIndex': 'int',
                                                                      'tIndex': 'int',
                                                                      'uIndex': 'int'}}],
                                            'addElements': [{'argInfo': {'sIndices': {'doc': 'the array of s indices to be added ',
                                                                                      'type': 'MIntArray'},
                                                                         'tIndices': {'doc': 'the array of t indices to be added ',
                                                                                      'type': 'MIntArray'},
                                                                         'uIndices': {'doc': 'the array of u indices to be added',
                                                                                      'type': 'MIntArray'}},
                                                             'args': [('sIndices',
                                                                       'MIntArray',
                                                                       'in'),
                                                                      ('tIndices',
                                                                       'MIntArray',
                                                                       'in'),
                                                                      ('uIndices',
                                                                       'MIntArray',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nAdd the specified elements to the component.',
                                                             'inArgs': ['sIndices',
                                                                        'tIndices',
                                                                        'uIndices'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'sIndices': ['const',
                                                                                             '&'],
                                                                                'tIndices': ['const',
                                                                                             '&'],
                                                                                'uIndices': ['const',
                                                                                             '&']},
                                                             'types': {'sIndices': 'MIntArray',
                                                                       'tIndices': 'MIntArray',
                                                                       'uIndices': 'MIntArray'}}],
                                            'className': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nClass name. \n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'create': [{'argInfo': {'compType': {'doc': 'the type of component to create ',
                                                                                 'type': ('MFn',
                                                                                          'Type')}},
                                                        'args': [('compType',
                                                                  ('MFn',
                                                                   'Type'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nCreate a triple indexed component of the given type. Allowable types are',
                                                        'inArgs': ['compType'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The new component',
                                                                       'qualifiers': [],
                                                                       'type': 'MObject'},
                                                        'returnType': 'MObject',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'compType': []},
                                                        'types': {'compType': ('MFn',
                                                                               'Type')}}],
                                            'getCompleteData': [{'argInfo': {'maxS': {'doc': 'storage for the maximum number of S elements ',
                                                                                      'type': 'int'},
                                                                             'maxT': {'doc': 'storage for the maximum number of T elements ',
                                                                                      'type': 'int'},
                                                                             'maxU': {'doc': 'storage for the maximum number of U elements',
                                                                                      'type': 'int'}},
                                                                 'args': [('maxS',
                                                                           'int',
                                                                           'out'),
                                                                          ('maxT',
                                                                           'int',
                                                                           'out'),
                                                                          ('maxU',
                                                                           'int',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nReturns the number of elements for the complete component. A complete component means that all elements are selected.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setCompleteData',
                                                                             False),
                                                                 'outArgs': ['maxS',
                                                                             'maxT',
                                                                             'maxU'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'maxS': ['&'],
                                                                                    'maxT': ['&'],
                                                                                    'maxU': ['&']},
                                                                 'types': {'maxS': 'int',
                                                                           'maxT': 'int',
                                                                           'maxU': 'int'}}],
                                            'getElement': [{'argInfo': {'index': {'doc': 'the index of the element to retrieve ',
                                                                                  'type': 'int'},
                                                                        'sIndex': {'doc': 'the s index of the component ',
                                                                                   'type': 'int'},
                                                                        'tIndex': {'doc': 'the t index of the component ',
                                                                                   'type': 'int'},
                                                                        'uIndex': {'doc': 'the u index of the component',
                                                                                   'type': 'int'}},
                                                            'args': [('index',
                                                                      'int',
                                                                      'in'),
                                                                     ('sIndex',
                                                                      'int',
                                                                      'out'),
                                                                     ('tIndex',
                                                                      'int',
                                                                      'out'),
                                                                     ('uIndex',
                                                                      'int',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nGet the specified element from the component.',
                                                            'inArgs': ['index'],
                                                            'outArgs': ['sIndex',
                                                                        'tIndex',
                                                                        'uIndex'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'index': [],
                                                                               'sIndex': ['&'],
                                                                               'tIndex': ['&'],
                                                                               'uIndex': ['&']},
                                                            'types': {'index': 'int',
                                                                      'sIndex': 'int',
                                                                      'tIndex': 'int',
                                                                      'uIndex': 'int'}}],
                                            'getElements': [{'argInfo': {'sIndices': {'doc': 'storage for the array of s indices ',
                                                                                      'type': 'MIntArray'},
                                                                         'tIndices': {'doc': 'storage for the array of t indices ',
                                                                                      'type': 'MIntArray'},
                                                                         'uIndices': {'doc': 'storage for the array of u indices',
                                                                                      'type': 'MIntArray'}},
                                                             'args': [('sIndices',
                                                                       'MIntArray',
                                                                       'out'),
                                                                      ('tIndices',
                                                                       'MIntArray',
                                                                       'out'),
                                                                      ('uIndices',
                                                                       'MIntArray',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nGet all of the element indices from the component.',
                                                             'inArgs': [],
                                                             'outArgs': ['sIndices',
                                                                         'tIndices',
                                                                         'uIndices'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'sIndices': ['&'],
                                                                                'tIndices': ['&'],
                                                                                'uIndices': ['&']},
                                                             'types': {'sIndices': 'MIntArray',
                                                                       'tIndices': 'MIntArray',
                                                                       'uIndices': 'MIntArray'}}],
                                            'setCompleteData': [{'argInfo': {'maxS': {'doc': 'the maximum number of S elements ',
                                                                                      'type': 'int'},
                                                                             'maxT': {'doc': 'the maximum number of T elements ',
                                                                                      'type': 'int'},
                                                                             'maxU': {'doc': 'the maximum number of U elements',
                                                                                      'type': 'int'}},
                                                                 'args': [('maxS',
                                                                           'int',
                                                                           'in'),
                                                                          ('maxT',
                                                                           'int',
                                                                           'in'),
                                                                          ('maxU',
                                                                           'int',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nMarks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].',
                                                                 'inArgs': ['maxS',
                                                                            'maxT',
                                                                            'maxU'],
                                                                 'inverse': ('getCompleteData',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'maxS': [],
                                                                                    'maxT': [],
                                                                                    'maxU': []},
                                                                 'types': {'maxS': 'int',
                                                                           'maxT': 'int',
                                                                           'maxU': 'int'}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nFunction set type. \n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                                'pymelEnums': {}},
  'MFnTurbulenceField': {'enums': {},
                         'invertibles': [('setPhase', 'phase'),
                                         ('setFrequency', 'frequency')],
                         'methods': {'frequency': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the frequency parameter that generates irregularities in the fields motion.',
                                                    'inArgs': [],
                                                    'inverse': ('setFrequency',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A value representing a noise generation parameter.',
                                                                   'qualifiers': [],
                                                                   'type': 'double'},
                                                    'returnType': 'double',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                     'phase': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the phase shift parameter that influences the direction of the turbulence field disruption. Currently this returns the phaseZ attribute, which was called simply phase in versions of Maya prior to 3.0.',
                                                'inArgs': [],
                                                'inverse': ('setPhase',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A value representing a noise generation parameter.',
                                                               'qualifiers': [],
                                                               'type': 'double'},
                                                'returnType': 'double',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                     'setFrequency': [{'argInfo': {'value': {'doc': 'A value representing a noise generation parameter.',
                                                                             'type': 'double'}},
                                                       'args': [('value',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets the frequency parameter of the Perlin noise function used by the turbulence field. Values are positive, with larger values causing more frequent irregularities in the motion.',
                                                       'inArgs': ['value'],
                                                       'inverse': ('frequency',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'value': []},
                                                       'types': {'value': 'double'}}],
                                     'setPhase': [{'argInfo': {'value': {'doc': 'A value representing a noise generation parameter.',
                                                                         'type': 'double'}},
                                                   'args': [('value',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the phase shift parameter of the Perlin noise function used by the turbulence field. Both positive and negative values are legal and influence the direction of the disruption. Sets the phaseZ parameter, which was called simply phase in versions of Maya prior to 3.0.',
                                                   'inArgs': ['value'],
                                                   'inverse': ('phase',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'value': []},
                                                   'types': {'value': 'double'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nFunction set type. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {},
                         'pymelMethods': {'frequency': 'getFrequency',
                                          'phase': 'getPhase'}},
  'MFnTypedAttribute': {'enums': {},
                        'invertibles': [('setDefault', 'getDefault')],
                        'methods': {'attrType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the type of this attribute.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'An element of the MFnData::Type enum.',
                                                                 'qualifiers': [],
                                                                 'type': ('MFnData',
                                                                          'Type')},
                                                  'returnType': ('MFnData',
                                                                 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nClass name. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'create': [{'argInfo': {'brief': {'doc': 'Short name for the attribute. ',
                                                                      'type': 'MString'},
                                                            'defaultData': {'doc': 'Default data for the attribute. ',
                                                                            'type': 'MObject'},
                                                            'full': {'doc': 'Full name for the new attribute. ',
                                                                     'type': 'MString'},
                                                            'id': {'doc': "Type id of the attribute's data. ",
                                                                   'type': 'MTypeId'}},
                                                'args': [('full',
                                                          'MString',
                                                          'in'),
                                                         ('brief',
                                                          'MString',
                                                          'in'),
                                                         ('id',
                                                          'MTypeId',
                                                          'in'),
                                                         ('defaultData',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {'defaultData': 'MObject::kNullObj'},
                                                'deprecated': False,
                                                'doc': '\r\nCreate a new typed attribute with the given type.',
                                                'inArgs': ['full',
                                                           'brief',
                                                           'id',
                                                           'defaultData'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Pointer to the new attribute object.',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'brief': ['const',
                                                                             '&'],
                                                                   'defaultData': [],
                                                                   'full': ['const',
                                                                            '&'],
                                                                   'id': ['const',
                                                                          '&']},
                                                'types': {'brief': 'MString',
                                                          'defaultData': 'MObject',
                                                          'full': 'MString',
                                                          'id': 'MTypeId'}},
                                               {'argInfo': {'brief': {'doc': 'Short name for the attribute. ',
                                                                      'type': 'MString'},
                                                            'defaultData': {'doc': 'Default data for the attribute. ',
                                                                            'type': 'MObject'},
                                                            'full': {'doc': 'Full name for the new attribute. ',
                                                                     'type': 'MString'},
                                                            'type': {'doc': "Type of the attribute's data. ",
                                                                     'type': ('MFnData',
                                                                              'Type')}},
                                                'args': [('full',
                                                          'MString',
                                                          'in'),
                                                         ('brief',
                                                          'MString',
                                                          'in'),
                                                         ('type',
                                                          ('MFnData',
                                                           'Type'),
                                                          'in'),
                                                         ('defaultData',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {'defaultData': 'MObject::kNullObj'},
                                                'deprecated': False,
                                                'doc': '\r\nCreate a new typed attribute with the given type.',
                                                'inArgs': ['full',
                                                           'brief',
                                                           'type',
                                                           'defaultData'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Pointer to the new attribute object.',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'brief': ['const',
                                                                             '&'],
                                                                   'defaultData': [],
                                                                   'full': ['const',
                                                                            '&'],
                                                                   'type': []},
                                                'types': {'brief': 'MString',
                                                          'defaultData': 'MObject',
                                                          'full': 'MString',
                                                          'type': ('MFnData',
                                                                   'Type')}}],
                                    'getDefault': [{'argInfo': {'defaultData': {'doc': "receives a copy of the attribute's default data.",
                                                                                'type': 'MObject'}},
                                                    'args': [('defaultData',
                                                              'MObject',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the default data for this attribute. The data can then be operated on using the appropriate MFn*Data functionset.',
                                                    'inArgs': [],
                                                    'inverse': ('setDefault',
                                                                False),
                                                    'outArgs': ['defaultData'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'defaultData': ['&']},
                                                    'types': {'defaultData': 'MObject'}}],
                                    'setDefault': [{'argInfo': {'defaultData': {'doc': 'default data for the attribute',
                                                                                'type': 'MObject'}},
                                                    'args': [('defaultData',
                                                              'MObject',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the default data for this attribute. The data can be created using the appropriate MFn*Data function set.',
                                                    'inArgs': ['defaultData'],
                                                    'inverse': ('getDefault',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'defaultData': ['const',
                                                                                       '&']},
                                                    'types': {'defaultData': 'MObject'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFunction set type. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn',
                                                             'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFnUInt64ArrayData': {'enums': {},
                         'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the MUint64 to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nNO SCRIPT SUPPORT. \n',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated MUint64 ',
                                                                     'qualifiers': [],
                                                                     'type': 'MUint64'},
                                                      'returnType': 'MUint64',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}},
                                                     {'argInfo': {'index': {'doc': 'the index of the MUint64 to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nExtract the indicated MUint64 from the instance. by the function set. The MUint64 returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated MUint64 ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MUint64'},
                                                      'returnType': 'MUint64',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                                     'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturn an  MUint64Array  containing the MUint64 array currently operated upon by the function set. The  MUint64Array  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A copy of the MUint64Array held in this instance ',
                                                               'qualifiers': [],
                                                               'type': 'MUint64Array'},
                                                'returnType': 'MUint64Array',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nClass name. \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MUint64Array to populate',
                                                                      'type': 'MUint64Array'}},
                                                 'args': [('dest',
                                                           'MUint64Array',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nCopy all the MUint64s in the instance into the given  MUint64Array .',
                                                 'inArgs': [],
                                                 'outArgs': ['dest'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'dest': ['&']},
                                                 'types': {'dest': 'MUint64Array'}}],
                                     'create': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nCreate a new  MObject , attach it to this instance, and initialize it to be empty.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                     'type': 'MUint64Array'}},
                                                 'args': [('arr',
                                                           'MUint64Array',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nCreate a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MUint64Array .',
                                                 'inArgs': ['arr'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MUint64Array'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturn the number of MUint64s in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of MUint64s in the instance ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                     'set': [{'argInfo': {'element': {'doc': 'the element ',
                                                                      'type': 'MUint64'},
                                                          'index': {'doc': 'the index of the MUint64 to set',
                                                                    'type': 'uint'}},
                                              'args': [('element',
                                                        'MUint64',
                                                        'in'),
                                                       ('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSet the element at the specified index of the array.',
                                              'inArgs': ['element',
                                                         'index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'element': [],
                                                                 'index': ['unsigned']},
                                              'types': {'element': 'MUint64',
                                                        'index': 'uint'}},
                                             {'argInfo': {'array': {'doc': 'the MUint64Array containing the data to set into this instance',
                                                                    'type': 'MUint64Array'}},
                                              'args': [('array',
                                                        'MUint64Array',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSet the instance to contain the MUint64s defined in the given  MUint64Array .',
                                              'inArgs': ['array'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['const',
                                                                           '&']},
                                              'types': {'array': 'MUint64Array'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nFunction set type. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnUint64SingleIndexedComponent': {'enums': {},
                                      'invertibles': [('setCompleteData',
                                                       'getCompleteData')],
                                      'methods': {'addElement': [{'argInfo': {'element': {'doc': 'the element index to be added',
                                                                                          'type': 'MUint64'}},
                                                                  'args': [('element',
                                                                            'MUint64',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nAdd the specified element to the component.',
                                                                  'inArgs': ['element'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'element': []},
                                                                  'types': {'element': 'MUint64'}}],
                                                  'addElements': [{'argInfo': {'elements': {'doc': 'the array of element indices to be added',
                                                                                            'type': 'MUint64Array'}},
                                                                   'args': [('elements',
                                                                             'MUint64Array',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nAdd the specified elements to the component.',
                                                                   'inArgs': ['elements'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'elements': ['const',
                                                                                                   '&']},
                                                                   'types': {'elements': 'MUint64Array'}}],
                                                  'className': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nClass name. \n',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': ['*'],
                                                                                'type': 'char'},
                                                                 'returnType': 'char',
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                                  'create': [{'argInfo': {'compType': {'doc': 'the type of component to create ',
                                                                                       'type': ('MFn',
                                                                                                'Type')}},
                                                              'args': [('compType',
                                                                        ('MFn',
                                                                         'Type'),
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nCreate a single indexed component of the given type. Allowable types are',
                                                              'inArgs': ['compType'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The new component',
                                                                             'qualifiers': [],
                                                                             'type': 'MObject'},
                                                              'returnType': 'MObject',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'compType': []},
                                                              'types': {'compType': ('MFn',
                                                                                     'Type')}}],
                                                  'element': [{'argInfo': {'index': {'doc': 'the index of the element to retrieve ',
                                                                                     'type': 'int'}},
                                                               'args': [('index',
                                                                         'int',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nReturns the specified element from the component.',
                                                               'inArgs': ['index'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The index of the specified component',
                                                                              'qualifiers': [],
                                                                              'type': 'MUint64'},
                                                               'returnType': 'MUint64',
                                                               'static': False,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'index': []},
                                                               'types': {'index': 'int'}}],
                                                  'getCompleteData': [{'argInfo': {'numElements': {'doc': 'storage for the maximum number of elements',
                                                                                                   'type': 'MUint64'}},
                                                                       'args': [('numElements',
                                                                                 'MUint64',
                                                                                 'out')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\nReturns the number of elements for the complete component. A complete component means that all elements are selected.',
                                                                       'inArgs': [],
                                                                       'inverse': ('setCompleteData',
                                                                                   False),
                                                                       'outArgs': ['numElements'],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'numElements': ['&']},
                                                                       'types': {'numElements': 'MUint64'}}],
                                                  'getElements': [{'argInfo': {'elements': {'doc': 'storage for the array of indices',
                                                                                            'type': 'MUint64Array'}},
                                                                   'args': [('elements',
                                                                             'MUint64Array',
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nGet all of the element indices from the component.',
                                                                   'inArgs': [],
                                                                   'outArgs': ['elements'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'elements': ['&']},
                                                                   'types': {'elements': 'MUint64Array'}}],
                                                  'setCompleteData': [{'argInfo': {'numElements': {'doc': 'the maximum number of elements in the component',
                                                                                                   'type': 'MUint64'}},
                                                                       'args': [('numElements',
                                                                                 'MUint64',
                                                                                 'in')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\nMarks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].',
                                                                       'inArgs': ['numElements'],
                                                                       'inverse': ('getCompleteData',
                                                                                   True),
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'numElements': []},
                                                                       'types': {'numElements': 'MUint64'}}],
                                                  'type': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nFunction set type. \n',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                            'returnType': ('MFn',
                                                                           'Type'),
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}]},
                                      'pymelEnums': {}},
  'MFnUniformField': {'enums': {},
                      'invertibles': [('setDirection', 'direction')],
                      'methods': {'direction': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the direction the uniform field pushes objects.',
                                                 'inArgs': [],
                                                 'inverse': ('setDirection',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A vector representing direction.',
                                                                'qualifiers': [],
                                                                'type': 'MVector'},
                                                 'returnType': 'MVector',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                  'setDirection': [{'argInfo': {'uniformDirection': {'doc': 'A vector representing direction.',
                                                                                     'type': 'MVector'}},
                                                    'args': [('uniformDirection',
                                                              'MVector',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets the direction the uniform field pushes objects.',
                                                    'inArgs': ['uniformDirection'],
                                                    'inverse': ('direction',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'uniformDirection': ['const',
                                                                                            '&']},
                                                    'types': {'uniformDirection': 'MVector'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFunction set type. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'direction': 'getDirection'}},
  'MFnUnitAttribute': {'enums': {'Type': {'valueDocs': {'angle': 'Angular attribute.',
                                                        'distance': 'Distance (linear) attribute.',
                                                        'invalid': 'Invalid unit type.',
                                                        'kAngle': 'Angular attribute.',
                                                        'kDistance': 'Distance (linear) attribute.',
                                                        'kInvalid': 'Invalid unit type.',
                                                        'kLast': 'Last value, for counting.',
                                                        'kTime': 'Time attribute.',
                                                        'last': 'Last value, for counting.',
                                                        'time': 'Time attribute.'},
                                          'values': "Enum('Type', {'kInvalid': 0, 'kAngle': 1, 'kDistance': 2, 'kTime': 3, 'kLast': 4})"}},
                       'invertibles': [('setMin', 'getMin'),
                                       ('setSoftMin', 'getSoftMin'),
                                       ('setMax', 'getMax'),
                                       ('setSoftMax', 'getSoftMax'),
                                       ('setDefault', 'getDefault')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nClass name. \r\n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'create': [{'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                     'type': 'MString'},
                                                           'defaultValue': {'doc': 'the default value for the new attribute ',
                                                                            'type': 'double'},
                                                           'full': {'doc': 'the full (or int) name of the attribute ',
                                                                    'type': 'MString'},
                                                           'unitType': {'doc': 'an element of the MFnUnitAttribute::Type enum ',
                                                                        'type': ('MFnUnitAttribute',
                                                                                 'Type')}},
                                               'args': [('full',
                                                         'MString',
                                                         'in'),
                                                        ('brief',
                                                         'MString',
                                                         'in'),
                                                        ('unitType',
                                                         ('MFnUnitAttribute',
                                                          'Type'),
                                                         'in'),
                                                        ('defaultValue',
                                                         'double',
                                                         'in')],
                                               'defaults': {'defaultValue': 0.0},
                                               'deprecated': False,
                                               'doc': '\r\nCreate a new unit attribute and return it as an  MObject . For both angle and distance attributes, the attribute is type independent. For example, you define an angular attribute as containing an angle in radians. The defaultValue passed to the create method must be in these units, and the value in those units will be returned by the get and set methods. If this method is used to instantiate a time attribute, the units stored in the attribute will be those of the current default time unit (see  MTime ).',
                                               'inArgs': ['full',
                                                          'brief',
                                                          'unitType',
                                                          'defaultValue'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'brief': ['const',
                                                                            '&'],
                                                                  'defaultValue': [],
                                                                  'full': ['const',
                                                                           '&'],
                                                                  'unitType': []},
                                               'types': {'brief': 'MString',
                                                         'defaultValue': 'double',
                                                         'full': 'MString',
                                                         'unitType': ('MFnUnitAttribute',
                                                                      'Type')}},
                                              {'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                     'type': 'MString'},
                                                           'defaultValue': {'doc': 'the default value for the new attribute ',
                                                                            'type': 'MTime'},
                                                           'full': {'doc': 'the full (or int) name of the attribute ',
                                                                    'type': 'MString'}},
                                               'args': [('full',
                                                         'MString',
                                                         'in'),
                                                        ('brief',
                                                         'MString',
                                                         'in'),
                                                        ('defaultValue',
                                                         'MTime',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nCreate a new unit attribute of type  time  and return it as an  MObject . The units of the time value stored in the attribute will be those of the current default time units in effect (see  MTime ).',
                                               'inArgs': ['full',
                                                          'brief',
                                                          'defaultValue'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'brief': ['const',
                                                                            '&'],
                                                                  'defaultValue': ['const',
                                                                                   '&'],
                                                                  'full': ['const',
                                                                           '&']},
                                               'types': {'brief': 'MString',
                                                         'defaultValue': 'MTime',
                                                         'full': 'MString'}},
                                              {'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                     'type': 'MString'},
                                                           'defaultValue': {'doc': 'the default value for the new attribute ',
                                                                            'type': 'MAngle'},
                                                           'full': {'doc': 'the full (or int) name of the attribute ',
                                                                    'type': 'MString'}},
                                               'args': [('full',
                                                         'MString',
                                                         'in'),
                                                        ('brief',
                                                         'MString',
                                                         'in'),
                                                        ('defaultValue',
                                                         'MAngle',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nCreate a new unit attribute of type  angle  and return it as an  MObject .',
                                               'inArgs': ['full',
                                                          'brief',
                                                          'defaultValue'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'brief': ['const',
                                                                            '&'],
                                                                  'defaultValue': ['const',
                                                                                   '&'],
                                                                  'full': ['const',
                                                                           '&']},
                                               'types': {'brief': 'MString',
                                                         'defaultValue': 'MAngle',
                                                         'full': 'MString'}},
                                              {'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute ',
                                                                     'type': 'MString'},
                                                           'defaultValue': {'doc': 'the default value for the new attribute ',
                                                                            'type': 'MDistance'},
                                                           'full': {'doc': 'the full (or int) name of the attribute ',
                                                                    'type': 'MString'}},
                                               'args': [('full',
                                                         'MString',
                                                         'in'),
                                                        ('brief',
                                                         'MString',
                                                         'in'),
                                                        ('defaultValue',
                                                         'MDistance',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nCreate a new unit attribute of type  distance  and return it as an  MObject .',
                                               'inArgs': ['full',
                                                          'brief',
                                                          'defaultValue'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'An MObject representing the new attribute ',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'brief': ['const',
                                                                            '&'],
                                                                  'defaultValue': ['const',
                                                                                   '&'],
                                                                  'full': ['const',
                                                                           '&']},
                                               'types': {'brief': 'MString',
                                                         'defaultValue': 'MDistance',
                                                         'full': 'MString'}}],
                                   'getDefault': [{'argInfo': {'defaultValue': {'doc': 'returns the default value for this attribute. This method simply returns the given default value of the attribute as a double. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.).',
                                                                                'type': 'double'}},
                                                   'args': [('defaultValue',
                                                             'double',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGets the default value for this attribute. This routine simply returns the given double which represents the default value for the attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setDefault',
                                                               False),
                                                   'outArgs': ['defaultValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': ['&']},
                                                   'types': {'defaultValue': 'double'}},
                                                  {'argInfo': {'defaultValue': {'doc': 'returns the default value for this attribute',
                                                                                'type': 'MTime'}},
                                                   'args': [('defaultValue',
                                                             'MTime',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGets the default value for a time attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setDefault',
                                                               False),
                                                   'outArgs': ['defaultValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': ['&']},
                                                   'types': {'defaultValue': 'MTime'}},
                                                  {'argInfo': {'defaultValue': {'doc': 'returns the default value for this attribute in radians',
                                                                                'type': 'MAngle'}},
                                                   'args': [('defaultValue',
                                                             'MAngle',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGets the default value for this attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setDefault',
                                                               False),
                                                   'outArgs': ['defaultValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': ['&']},
                                                   'types': {'defaultValue': 'MAngle'}},
                                                  {'argInfo': {'defaultValue': {'doc': 'returns the default value for this attribute in centimeters',
                                                                                'type': 'MDistance'}},
                                                   'args': [('defaultValue',
                                                             'MDistance',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGets the default value for this attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setDefault',
                                                               False),
                                                   'outArgs': ['defaultValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': ['&']},
                                                   'types': {'defaultValue': 'MDistance'}}],
                                   'getMax': [{'argInfo': {'maxValue': {'doc': 'the maximum value for this attribute',
                                                                        'type': 'double'}},
                                               'args': [('maxValue',
                                                         'double',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the maximum value for this attribute. This routine simply returns the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and interpret the response appropriately.',
                                               'inArgs': [],
                                               'inverse': ('setMax',
                                                           False),
                                               'outArgs': ['maxValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['&']},
                                               'types': {'maxValue': 'double'}},
                                              {'argInfo': {'maxValue': {'doc': 'the maximum value for this attribute',
                                                                        'type': 'MTime'}},
                                               'args': [('maxValue',
                                                         'MTime',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the maximum value for this attribute.',
                                               'inArgs': [],
                                               'inverse': ('setMax',
                                                           False),
                                               'outArgs': ['maxValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['&']},
                                               'types': {'maxValue': 'MTime'}},
                                              {'argInfo': {'maxValue': {'doc': 'the maximum value for this attribute. The returned angle is always in radians',
                                                                        'type': 'MAngle'}},
                                               'args': [('maxValue',
                                                         'MAngle',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the maximum value for this attribute.',
                                               'inArgs': [],
                                               'inverse': ('setMax',
                                                           False),
                                               'outArgs': ['maxValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['&']},
                                               'types': {'maxValue': 'MAngle'}},
                                              {'argInfo': {'maxValue': {'doc': 'the maximum value for this attribute. The returned distance is always in centimeters',
                                                                        'type': 'MDistance'}},
                                               'args': [('maxValue',
                                                         'MDistance',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the maximum value for this attribute.',
                                               'inArgs': [],
                                               'inverse': ('setMax',
                                                           False),
                                               'outArgs': ['maxValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['&']},
                                               'types': {'maxValue': 'MDistance'}}],
                                   'getMin': [{'argInfo': {'minValue': {'doc': 'the minimum value for this attribute',
                                                                        'type': 'double'}},
                                               'args': [('minValue',
                                                         'double',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the minimum value for this attribute. This routine simply returns the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and interpret the response appropriately.',
                                               'inArgs': [],
                                               'inverse': ('setMin',
                                                           False),
                                               'outArgs': ['minValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['&']},
                                               'types': {'minValue': 'double'}},
                                              {'argInfo': {'minValue': {'doc': 'the minimum value for this attribute',
                                                                        'type': 'MTime'}},
                                               'args': [('minValue',
                                                         'MTime',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the minimum value for this attribute.',
                                               'inArgs': [],
                                               'inverse': ('setMin',
                                                           False),
                                               'outArgs': ['minValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['&']},
                                               'types': {'minValue': 'MTime'}},
                                              {'argInfo': {'minValue': {'doc': 'the minimum value for this attribute. The returned angle is always in radians',
                                                                        'type': 'MAngle'}},
                                               'args': [('minValue',
                                                         'MAngle',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the minimum value for this attribute.',
                                               'inArgs': [],
                                               'inverse': ('setMin',
                                                           False),
                                               'outArgs': ['minValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['&']},
                                               'types': {'minValue': 'MAngle'}},
                                              {'argInfo': {'minValue': {'doc': 'the minimum value for this attribute. The returned distance is always in centimeters',
                                                                        'type': 'MDistance'}},
                                               'args': [('minValue',
                                                         'MDistance',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the minimum value for this attribute.',
                                               'inArgs': [],
                                               'inverse': ('setMin',
                                                           False),
                                               'outArgs': ['minValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['&']},
                                               'types': {'minValue': 'MDistance'}}],
                                   'getSoftMax': [{'argInfo': {'maxValue': {'doc': 'the soft maximum value for this attribute',
                                                                            'type': 'double'}},
                                                   'args': [('maxValue',
                                                             'double',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft maximum value for this attribute. This routine simply returns the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and interpret the response appropriately.',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMax',
                                                               False),
                                                   'outArgs': ['maxValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': ['&']},
                                                   'types': {'maxValue': 'double'}},
                                                  {'argInfo': {'maxValue': {'doc': 'the soft maximum value for this attribute',
                                                                            'type': 'MTime'}},
                                                   'args': [('maxValue',
                                                             'MTime',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft maximum value for this attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMax',
                                                               False),
                                                   'outArgs': ['maxValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': ['&']},
                                                   'types': {'maxValue': 'MTime'}},
                                                  {'argInfo': {'maxValue': {'doc': 'the soft maximum value for this attribute. The returned angle is always in radians',
                                                                            'type': 'MAngle'}},
                                                   'args': [('maxValue',
                                                             'MAngle',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft maximum value for this attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMax',
                                                               False),
                                                   'outArgs': ['maxValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': ['&']},
                                                   'types': {'maxValue': 'MAngle'}},
                                                  {'argInfo': {'maxValue': {'doc': 'the soft maximum value for this attribute. The returned distance is always in centimeters',
                                                                            'type': 'MDistance'}},
                                                   'args': [('maxValue',
                                                             'MDistance',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft maximum value for this attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMax',
                                                               False),
                                                   'outArgs': ['maxValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': ['&']},
                                                   'types': {'maxValue': 'MDistance'}}],
                                   'getSoftMin': [{'argInfo': {'minValue': {'doc': 'the soft minimum value for this attribute',
                                                                            'type': 'double'}},
                                                   'args': [('minValue',
                                                             'double',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft minimum value for this attribute. This routine simply returns the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and interpret the response appropriately.',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMin',
                                                               False),
                                                   'outArgs': ['minValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': ['&']},
                                                   'types': {'minValue': 'double'}},
                                                  {'argInfo': {'minValue': {'doc': 'the soft minimum value for this attribute',
                                                                            'type': 'MTime'}},
                                                   'args': [('minValue',
                                                             'MTime',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft minimum value for this attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMin',
                                                               False),
                                                   'outArgs': ['minValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': ['&']},
                                                   'types': {'minValue': 'MTime'}},
                                                  {'argInfo': {'minValue': {'doc': 'the soft minimum value for this attribute',
                                                                            'type': 'MAngle'}},
                                                   'args': [('minValue',
                                                             'MAngle',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft minimum value for this attribute. The returned angle is always in radians',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMin',
                                                               False),
                                                   'outArgs': ['minValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': ['&']},
                                                   'types': {'minValue': 'MAngle'}},
                                                  {'argInfo': {'minValue': {'doc': 'the soft minimum value for this attribute. The returned distance is always in centimeters',
                                                                            'type': 'MDistance'}},
                                                   'args': [('minValue',
                                                             'MDistance',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the soft minimum value for this attribute.',
                                                   'inArgs': [],
                                                   'inverse': ('setSoftMin',
                                                               False),
                                                   'outArgs': ['minValue'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': ['&']},
                                                   'types': {'minValue': 'MDistance'}}],
                                   'hasMax': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermine whether or not this attribute has a maximum value set.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if the attribute has a maximum value, and false otherwise ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                   'hasMin': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermine whether or not this attribute has a minimum value set.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if the attribute has a minimum value, and false otherwise ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                   'hasSoftMax': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermine whether or not this attribute has a soft maximum value set.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'true if the attribute has a maximum value, and false otherwise ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                   'hasSoftMin': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermine whether or not this attribute has a soft minimum value set.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'true if the attribute has a minimum value, and false otherwise ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                   'setDefault': [{'argInfo': {'defaultValue': {'doc': 'the new default value for this attribute',
                                                                                'type': 'double'}},
                                                   'args': [('defaultValue',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet a new default value for this attribute. This routine simply stores the given double as the new default value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and provide the appropriate value.',
                                                   'inArgs': ['defaultValue'],
                                                   'inverse': ('getDefault',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': []},
                                                   'types': {'defaultValue': 'double'}},
                                                  {'argInfo': {'defaultValue': {'doc': 'the new default value for this attribute',
                                                                                'type': 'MTime'}},
                                                   'args': [('defaultValue',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet a new default value for a time attribute.',
                                                   'inArgs': ['defaultValue'],
                                                   'inverse': ('getDefault',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': ['const',
                                                                                       '&']},
                                                   'types': {'defaultValue': 'MTime'}},
                                                  {'argInfo': {'defaultValue': {'doc': 'the new default value for this attribute',
                                                                                'type': 'MAngle'}},
                                                   'args': [('defaultValue',
                                                             'MAngle',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet a new default value for this attribute.',
                                                   'inArgs': ['defaultValue'],
                                                   'inverse': ('getDefault',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': ['const',
                                                                                       '&']},
                                                   'types': {'defaultValue': 'MAngle'}},
                                                  {'argInfo': {'defaultValue': {'doc': 'the new default value for this attribute',
                                                                                'type': 'MDistance'}},
                                                   'args': [('defaultValue',
                                                             'MDistance',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet a new default value for this attribute.',
                                                   'inArgs': ['defaultValue'],
                                                   'inverse': ('getDefault',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'defaultValue': ['const',
                                                                                       '&']},
                                                   'types': {'defaultValue': 'MDistance'}}],
                                   'setMax': [{'argInfo': {'maxValue': {'doc': 'the new maximum value for this attribute',
                                                                        'type': 'double'}},
                                               'args': [('maxValue',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the maximum value for this attribute. This routine simply stores the given double as the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and provide the appropriate value.',
                                               'inArgs': ['maxValue'],
                                               'inverse': ('getMax',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': []},
                                               'types': {'maxValue': 'double'}},
                                              {'argInfo': {'maxValue': {'doc': 'the new maximum value for this attribute',
                                                                        'type': 'MTime'}},
                                               'args': [('maxValue',
                                                         'MTime',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the maximum value for this attribute.',
                                               'inArgs': ['maxValue'],
                                               'inverse': ('getMax',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['const',
                                                                               '&']},
                                               'types': {'maxValue': 'MTime'}},
                                              {'argInfo': {'maxValue': {'doc': 'the new maximum value for this attribute',
                                                                        'type': 'MAngle'}},
                                               'args': [('maxValue',
                                                         'MAngle',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the maximum value for this attribute.',
                                               'inArgs': ['maxValue'],
                                               'inverse': ('getMax',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['const',
                                                                               '&']},
                                               'types': {'maxValue': 'MAngle'}},
                                              {'argInfo': {'maxValue': {'doc': 'the new maximum value for this attribute',
                                                                        'type': 'MDistance'}},
                                               'args': [('maxValue',
                                                         'MDistance',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the maximum value for this attribute.',
                                               'inArgs': ['maxValue'],
                                               'inverse': ('getMax',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['const',
                                                                               '&']},
                                               'types': {'maxValue': 'MDistance'}}],
                                   'setMin': [{'argInfo': {'minValue': {'doc': 'the new minimum value for this attribute',
                                                                        'type': 'double'}},
                                               'args': [('minValue',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the minimum value for this attribute. This routine simply stores the given double as the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and provide the appropriate value.',
                                               'inArgs': ['minValue'],
                                               'inverse': ('getMin',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': []},
                                               'types': {'minValue': 'double'}},
                                              {'argInfo': {'minValue': {'doc': 'the new minimum value for this attribute',
                                                                        'type': 'MTime'}},
                                               'args': [('minValue',
                                                         'MTime',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the minimum value for this attribute.',
                                               'inArgs': ['minValue'],
                                               'inverse': ('getMin',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['const',
                                                                               '&']},
                                               'types': {'minValue': 'MTime'}},
                                              {'argInfo': {'minValue': {'doc': 'the new minimum value for this attribute',
                                                                        'type': 'MAngle'}},
                                               'args': [('minValue',
                                                         'MAngle',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the minimum value for this attribute.',
                                               'inArgs': ['minValue'],
                                               'inverse': ('getMin',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['const',
                                                                               '&']},
                                               'types': {'minValue': 'MAngle'}},
                                              {'argInfo': {'minValue': {'doc': 'the new minimum value for this attribute',
                                                                        'type': 'MDistance'}},
                                               'args': [('minValue',
                                                         'MDistance',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the minimum value for this attribute.',
                                               'inArgs': ['minValue'],
                                               'inverse': ('getMin',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'minValue': ['const',
                                                                               '&']},
                                               'types': {'minValue': 'MDistance'}}],
                                   'setSoftMax': [{'argInfo': {'maxValue': {'doc': 'the new soft maximum value for this attribute',
                                                                            'type': 'double'}},
                                                   'args': [('maxValue',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft maximum value for this attribute. This routine simply stores the given double as the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and provide the appropriate value.',
                                                   'inArgs': ['maxValue'],
                                                   'inverse': ('getSoftMax',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': []},
                                                   'types': {'maxValue': 'double'}},
                                                  {'argInfo': {'maxValue': {'doc': 'the new soft maximum value for this attribute',
                                                                            'type': 'MTime'}},
                                                   'args': [('maxValue',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft maximum value for this attribute.',
                                                   'inArgs': ['maxValue'],
                                                   'inverse': ('getSoftMax',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': ['const',
                                                                                   '&']},
                                                   'types': {'maxValue': 'MTime'}},
                                                  {'argInfo': {'maxValue': {'doc': 'the new soft maximum value for this attribute',
                                                                            'type': 'MAngle'}},
                                                   'args': [('maxValue',
                                                             'MAngle',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft maximum value for this attribute.',
                                                   'inArgs': ['maxValue'],
                                                   'inverse': ('getSoftMax',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': ['const',
                                                                                   '&']},
                                                   'types': {'maxValue': 'MAngle'}},
                                                  {'argInfo': {'maxValue': {'doc': 'the new soft maximum value for this attribute',
                                                                            'type': 'MDistance'}},
                                                   'args': [('maxValue',
                                                             'MDistance',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft maximum value for this attribute.',
                                                   'inArgs': ['maxValue'],
                                                   'inverse': ('getSoftMax',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'maxValue': ['const',
                                                                                   '&']},
                                                   'types': {'maxValue': 'MDistance'}}],
                                   'setSoftMin': [{'argInfo': {'minValue': {'doc': 'the new soft minimum value for this attribute',
                                                                            'type': 'double'}},
                                                   'args': [('minValue',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft minimum value for this attribute. This routine simply stores the given double as the numerical value of the attribute. It is up to the programmer to know the units used by this attribute (eg. radians for angular data, centimeters for distance data, etc.) and provide the appropriate value.',
                                                   'inArgs': ['minValue'],
                                                   'inverse': ('getSoftMin',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': []},
                                                   'types': {'minValue': 'double'}},
                                                  {'argInfo': {'minValue': {'doc': 'the new soft minimum value for this attribute',
                                                                            'type': 'MTime'}},
                                                   'args': [('minValue',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft minimum value for this attribute.',
                                                   'inArgs': ['minValue'],
                                                   'inverse': ('getSoftMin',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': ['const',
                                                                                   '&']},
                                                   'types': {'minValue': 'MTime'}},
                                                  {'argInfo': {'minValue': {'doc': 'the new soft minimum value for this attribute',
                                                                            'type': 'MAngle'}},
                                                   'args': [('minValue',
                                                             'MAngle',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft minimum value for this attribute.',
                                                   'inArgs': ['minValue'],
                                                   'inverse': ('getSoftMin',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': ['const',
                                                                                   '&']},
                                                   'types': {'minValue': 'MAngle'}},
                                                  {'argInfo': {'minValue': {'doc': 'the new soft minimum value for this attribute',
                                                                            'type': 'MDistance'}},
                                                   'args': [('minValue',
                                                             'MDistance',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the soft minimum value for this attribute.',
                                                   'inArgs': ['minValue'],
                                                   'inverse': ('getSoftMin',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'minValue': ['const',
                                                                                   '&']},
                                                   'types': {'minValue': 'MDistance'}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nFunction set type. \r\n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn',
                                                            'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                   'unitType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the unit type of this attribute.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'An element of the MFnUnitAttribute::Type enum ',
                                                                'qualifiers': [],
                                                                'type': ('MFnUnitAttribute',
                                                                         'Type')},
                                                 'returnType': ('MFnUnitAttribute',
                                                                'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}]},
                       'pymelEnums': {'Type': "Enum('Type', [('invalid', 0), ('kInvalid', 0), ('angle', 1), ('kAngle', 1), ('distance', 2), ('kDistance', 2), ('time', 3), ('kTime', 3), ('last', 4), ('kLast', 4)], multiKeys=True)"}},
  'MFnVectorArrayData': {'enums': {},
                         'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the vector to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated vector ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MVector'},
                                                      'returnType': 'MVector',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}},
                                                     {'argInfo': {'index': {'doc': 'the index of the vector to extract',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The indicated vector ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MVector'},
                                                      'returnType': 'MVector',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                                     'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn an  MVectorArray  containing the vector array currently operated upon by the function set. The  MVectorArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A copy of the MVectorArray held in this instance ',
                                                               'qualifiers': [],
                                                               'type': 'MVectorArray'},
                                                'returnType': 'MVectorArray',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nClass name. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MVectorArray to populate',
                                                                      'type': 'MVectorArray'}},
                                                 'args': [('dest',
                                                           'MVectorArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCopy all the vectors in the instance into the given  MVectorArray .',
                                                 'inArgs': [],
                                                 'outArgs': ['dest'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'dest': ['&']},
                                                 'types': {'dest': 'MVectorArray'}}],
                                     'create': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to be empty.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance ',
                                                                     'type': 'MVectorArray'}},
                                                 'args': [('arr',
                                                           'MVectorArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreate a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MVectorArray .',
                                                 'inArgs': ['arr'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The newly created MObject ',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MVectorArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the number of vectors in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of vectors in the instance ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                     'set': [{'argInfo': {'element': {'doc': 'the element ',
                                                                      'type': 'MVector'},
                                                          'index': {'doc': 'the index of the vector to set',
                                                                    'type': 'uint'}},
                                              'args': [('element',
                                                        'MVector',
                                                        'in'),
                                                       ('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the element at the specified index.',
                                              'inArgs': ['element',
                                                         'index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'element': ['&'],
                                                                 'index': ['unsigned']},
                                              'types': {'element': 'MVector',
                                                        'index': 'uint'}},
                                             {'argInfo': {'array': {'doc': 'the MVectorArray containing the data to set into this instance',
                                                                    'type': 'MVectorArray'}},
                                              'args': [('array',
                                                        'MVectorArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the instance to contain the vectors defined in the given  MVectorArray .',
                                              'inArgs': ['array'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'array': ['const',
                                                                           '&']},
                                              'types': {'array': 'MVectorArray'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nFunction set type. \r\n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnVolumeAxisField': {'enums': {},
                         'invertibles': [('setTurbulenceSpeed',
                                          'turbulenceSpeed'),
                                         ('setSpeedAwayFromAxis',
                                          'speedAwayFromAxis'),
                                         ('setDirection', 'direction'),
                                         ('setTurbulenceFrequency',
                                          'turbulenceFrequency'),
                                         ('setTurbulence', 'turbulence'),
                                         ('setTurbulenceOffset',
                                          'turbulenceOffset'),
                                         ('setSpeedAwayFromCenter',
                                          'speedAwayFromCenter'),
                                         ('setInvertAttenuation',
                                          'invertAttenuation'),
                                         ('setSpeedAroundAxis',
                                          'speedAroundAxis'),
                                         ('setSpeedAlongAxis',
                                          'speedAlongAxis'),
                                         ('setDirectionalSpeed',
                                          'directionalSpeed')],
                         'methods': {'detailTurbulence': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturns the intensity of a second higher frequency turbulence.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'A double value for the intensity of fine scale turbulence.',
                                                                          'qualifiers': [],
                                                                          'type': 'double'},
                                                           'returnType': 'double',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}},
                                                          {'argInfo': {'value': {'doc': 'A double representing the intensity of a second higher frequency turbulence.',
                                                                                 'type': 'double'}},
                                                           'args': [('value',
                                                                     'double',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the detailTurbulence attribute for the field force.',
                                                           'inArgs': ['value'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'value': []},
                                                           'types': {'value': 'double'}}],
                                     'direction': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the direction attribute for the field force.',
                                                    'inArgs': [],
                                                    'inverse': ('setDirection',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A vector representing direction.',
                                                                   'qualifiers': [],
                                                                   'type': 'MVector'},
                                                    'returnType': 'MVector',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                     'directionalSpeed': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturns the directionalSpeed attribute of the field.',
                                                           'inArgs': [],
                                                           'inverse': ('setDirectionalSpeed',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'A double value representing the directional speed.',
                                                                          'qualifiers': [],
                                                                          'type': 'double'},
                                                           'returnType': 'double',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                     'invertAttenuation': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturns the value of the invertAttenuation attribute for the field force.',
                                                            'inArgs': [],
                                                            'inverse': ('setInvertAttenuation',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': ' true Field is strongest close to volume outer boundary.  false Field is strongest close to volume center.  ',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                     'setDirection': [{'argInfo': {'direction': {'doc': 'A vector representing direction.',
                                                                                 'type': 'MVector'}},
                                                       'args': [('direction',
                                                                 'MVector',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets the direction attribute for the field force.',
                                                       'inArgs': ['direction'],
                                                       'inverse': ('direction',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'direction': ['const',
                                                                                        '&']},
                                                       'types': {'direction': 'MVector'}}],
                                     'setDirectionalSpeed': [{'argInfo': {'speed': {'doc': 'A double representing the directional speed.',
                                                                                    'type': 'double'}},
                                                              'args': [('speed',
                                                                        'double',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the directional speed attribute for the field force.',
                                                              'inArgs': ['speed'],
                                                              'inverse': ('directionalSpeed',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'speed': []},
                                                              'types': {'speed': 'double'}}],
                                     'setInvertAttenuation': [{'argInfo': {'enable': {'doc': 'Flag to invert falloff of intensity.',
                                                                                      'type': 'bool'}},
                                                               'args': [('enable',
                                                                         'bool',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nEnables the field will be stronger the closer to the edge of the volume a point is.',
                                                               'inArgs': ['enable'],
                                                               'inverse': ('invertAttenuation',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'enable': []},
                                                               'types': {'enable': 'bool'}}],
                                     'setSpeedAlongAxis': [{'argInfo': {'speed': {'doc': 'A double representing the speed along axis.',
                                                                                  'type': 'double'}},
                                                            'args': [('speed',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSets the speed along axis attribute for the field force.',
                                                            'inArgs': ['speed'],
                                                            'inverse': ('speedAlongAxis',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'speed': []},
                                                            'types': {'speed': 'double'}}],
                                     'setSpeedAroundAxis': [{'argInfo': {'speed': {'doc': 'A double representing the speed around axis.',
                                                                                   'type': 'double'}},
                                                             'args': [('speed',
                                                                       'double',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nSets the speed around axis attribute for the field force.',
                                                             'inArgs': ['speed'],
                                                             'inverse': ('speedAroundAxis',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'speed': []},
                                                             'types': {'speed': 'double'}}],
                                     'setSpeedAwayFromAxis': [{'argInfo': {'speed': {'doc': 'A double representing the speed away from axis.',
                                                                                     'type': 'double'}},
                                                               'args': [('speed',
                                                                         'double',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nSets the speed away from axis attribute for the field force.',
                                                               'inArgs': ['speed'],
                                                               'inverse': ('speedAwayFromAxis',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'speed': []},
                                                               'types': {'speed': 'double'}}],
                                     'setSpeedAwayFromCenter': [{'argInfo': {'speed': {'doc': 'A double representing the speed away from center.',
                                                                                       'type': 'double'}},
                                                                 'args': [('speed',
                                                                           'double',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the speed away from center attribute for the field force.',
                                                                 'inArgs': ['speed'],
                                                                 'inverse': ('speedAwayFromCenter',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'speed': []},
                                                                 'types': {'speed': 'double'}}],
                                     'setTurbulence': [{'argInfo': {'value': {'doc': 'A double representing the turbulence intensity.',
                                                                              'type': 'double'}},
                                                        'args': [('value',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the turbulence attribute for the field force.',
                                                        'inArgs': ['value'],
                                                        'inverse': ('turbulence',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'value': []},
                                                        'types': {'value': 'double'}}],
                                     'setTurbulenceFrequency': [{'argInfo': {'value': {'doc': 'A vector representing the frequency of turbulence.',
                                                                                       'type': 'MVector'}},
                                                                 'args': [('value',
                                                                           'MVector',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the turbulenceFrequency attribute for the field force.',
                                                                 'inArgs': ['value'],
                                                                 'inverse': ('turbulenceFrequency',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'value': ['const',
                                                                                              '&']},
                                                                 'types': {'value': 'MVector'}}],
                                     'setTurbulenceOffset': [{'argInfo': {'value': {'doc': 'A vector representing the translation of turbulence.',
                                                                                    'type': 'MVector'}},
                                                              'args': [('value',
                                                                        'MVector',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the turbulenceOffset attribute for the field force.',
                                                              'inArgs': ['value'],
                                                              'inverse': ('turbulenceOffset',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'value': ['const',
                                                                                           '&']},
                                                              'types': {'value': 'MVector'}}],
                                     'setTurbulenceSpeed': [{'argInfo': {'value': {'doc': 'A double representing the rate of change of the turbulence.',
                                                                                   'type': 'double'}},
                                                             'args': [('value',
                                                                       'double',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nSets the turbulence speed attribute for the field force.',
                                                             'inArgs': ['value'],
                                                             'inverse': ('turbulenceSpeed',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'value': []},
                                                             'types': {'value': 'double'}}],
                                     'speedAlongAxis': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the alongAxis attribute of the field.',
                                                         'inArgs': [],
                                                         'inverse': ('setSpeedAlongAxis',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A double value representing the speed along axis.',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                     'speedAroundAxis': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the aroundAxis attribute of the field.',
                                                          'inArgs': [],
                                                          'inverse': ('setSpeedAroundAxis',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'A double value representing the speed around axis.',
                                                                         'qualifiers': [],
                                                                         'type': 'double'},
                                                          'returnType': 'double',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                     'speedAwayFromAxis': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nReturns the awayFromAxis attribute of the field.',
                                                            'inArgs': [],
                                                            'inverse': ('setSpeedAwayFromAxis',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'A double value representing the speed away from axis.',
                                                                           'qualifiers': [],
                                                                           'type': 'double'},
                                                            'returnType': 'double',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                     'speedAwayFromCenter': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nReturns the awayFromCenter attribute of the field.',
                                                              'inArgs': [],
                                                              'inverse': ('setSpeedAwayFromCenter',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'A double value representing the speed away from center.',
                                                                             'qualifiers': [],
                                                                             'type': 'double'},
                                                              'returnType': 'double',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                     'turbulence': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturns the turbulence intensity of the field.',
                                                     'inArgs': [],
                                                     'inverse': ('setTurbulence',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A double value representing the turbulence intensity.',
                                                                    'qualifiers': [],
                                                                    'type': 'double'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                     'turbulenceFrequency': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nReturns the turbulenceFrequency attribute for the field force.',
                                                              'inArgs': [],
                                                              'inverse': ('setTurbulenceFrequency',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'A vector representing frequency or scale of the turbulence.',
                                                                             'qualifiers': [],
                                                                             'type': 'MVector'},
                                                              'returnType': 'MVector',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                                              'types': {}}],
                                     'turbulenceOffset': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturns the turbulenceOffset attribute for the field force.',
                                                           'inArgs': [],
                                                           'inverse': ('setTurbulenceOffset',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'A vector representing an offset or translation of the turbulence.',
                                                                          'qualifiers': [],
                                                                          'type': 'MVector'},
                                                           'returnType': 'MVector',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                     'turbulenceSpeed': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the rate of change of the turbulence over time.',
                                                          'inArgs': [],
                                                          'inverse': ('setTurbulenceSpeed',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'A double value representing the turbulence speed.',
                                                                         'qualifiers': [],
                                                                         'type': 'double'},
                                                          'returnType': 'double',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nFunction set type. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn',
                                                              'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {},
                         'pymelMethods': {'direction': 'getDirection',
                                          'directionalSpeed': 'getDirectionalSpeed',
                                          'invertAttenuation': 'getInvertAttenuation',
                                          'speedAlongAxis': 'getSpeedAlongAxis',
                                          'speedAroundAxis': 'getSpeedAroundAxis',
                                          'speedAwayFromAxis': 'getSpeedAwayFromAxis',
                                          'speedAwayFromCenter': 'getSpeedAwayFromCenter',
                                          'turbulence': 'getTurbulence',
                                          'turbulenceFrequency': 'getTurbulenceFrequency',
                                          'turbulenceOffset': 'getTurbulenceOffset',
                                          'turbulenceSpeed': 'getTurbulenceSpeed'}},
  'MFnVolumeLight': {'enums': {'MLightDirection': {'valueDocs': {'downAxis': 'Light travels down the axis, like a directional light pointing in the negative Y direction.',
                                                                 'inward': 'Light travels inward toward the center of a box- or sphere-shaped volume, and inward toward the axis of a cylinder- or cone-shaped volume.',
                                                                 'kDownAxis': 'Light travels down the axis, like a directional light pointing in the negative Y direction.',
                                                                 'kInward': 'Light travels inward toward the center of a box- or sphere-shaped volume, and inward toward the axis of a cylinder- or cone-shaped volume.',
                                                                 'kOutward': 'Light travels outwared from the center of a box- or sphere-shaped volume, and outward from the axis of a cylinder- or cone-shaped volume.',
                                                                 'outward': 'Light travels outwared from the center of a box- or sphere-shaped volume, and outward from the axis of a cylinder- or cone-shaped volume.'},
                                                   'values': "Enum('MLightDirection', {'kOutward': 0, 'kInward': 1, 'kDownAxis': 2})"},
                               'MLightShape': {'valueDocs': {'boxVolume': '',
                                                             'coneVolume': '',
                                                             'cylinderVolume': '',
                                                             'kBoxVolume': '',
                                                             'kConeVolume': '',
                                                             'kCylinderVolume': '',
                                                             'kSphereVolume': '',
                                                             'sphereVolume': ''},
                                               'values': "Enum('MLightShape', {'kBoxVolume': 0, 'kSphereVolume': 1, 'kCylinderVolume': 2, 'kConeVolume': 3})"}},
                     'invertibles': [('setEmitAmbient', 'emitAmbient'),
                                     ('setConeEndRadius', 'coneEndRadius'),
                                     ('setLightShape', 'lightShape'),
                                     ('setVolumeLightDirection',
                                      'volumeLightDirection'),
                                     ('setArc', 'arc'),
                                     ('setShadowAngle', 'shadowAngle')],
                     'methods': {'arc': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nRetrieves the value of the "arc" attribute. The arc is an angular slice of the light about the y axis. The value can range from 0 to 360 degrees.',
                                          'inArgs': [],
                                          'inverse': ('setArc', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The value of the "arc" attribute of the volume light node.',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClass name. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'colorRamp': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRetrieves the "colorRamp" attribute.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The color ramp attribute',
                                                               'qualifiers': [],
                                                               'type': 'MRampAttribute'},
                                                'returnType': 'MRampAttribute',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                 'coneEndRadius': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRetrieves the value of the "coneEndRadius" attribute. The coneEndRadius attribute determines the relative size of the one end of the cone. At a value of 1.0 it is a cylinder, while at 0 it is a cone.',
                                                    'inArgs': [],
                                                    'inverse': ('setConeEndRadius',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The value of the "coneEndRadius" attribute of the volume light node.',
                                                                   'qualifiers': [],
                                                                   'type': 'float'},
                                                    'returnType': 'float',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                 'create': [{'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                       'type': 'bool'}},
                                             'args': [('UIvisible',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'UIvisible': True},
                                             'deprecated': False,
                                             'doc': '\r\nCreates a new volume light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                             'inArgs': ['UIvisible'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'UIvisible': []},
                                             'types': {'UIvisible': 'bool'}},
                                            {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                       'type': 'bool'},
                                                         'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                    'type': 'MObject'},
                                                         'wantTransform': {'doc': "Boolean to indicate whether the transform node is needed or not, which is 'false' by default. ",
                                                                           'type': 'bool'}},
                                             'args': [('parent',
                                                       'MObject',
                                                       'in'),
                                                      ('UIvisible',
                                                       'bool',
                                                       'in'),
                                                      ('wantTransform',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'UIvisible': True,
                                                          'wantTransform': False},
                                             'deprecated': False,
                                             'doc': '\r\nCreates a new volume light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.',
                                             'inArgs': ['parent',
                                                        'UIvisible',
                                                        'wantTransform'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'UIvisible': [],
                                                                'parent': ['const',
                                                                           '&'],
                                                                'wantTransform': []},
                                             'types': {'UIvisible': 'bool',
                                                       'parent': 'MObject',
                                                       'wantTransform': 'bool'}},
                                            {'argInfo': {'UIvisible': {'doc': 'determines whether or not to connect the new node to the light classification node and add it to the default light list. ',
                                                                       'type': 'bool'},
                                                         'parent': {'doc': 'the node under which the new light and its transform will be added. ',
                                                                    'type': 'MObject'}},
                                             'args': [('parent',
                                                       'MObject',
                                                       'in'),
                                                      ('UIvisible',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'UIvisible': True},
                                             'deprecated': False,
                                             'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                             'inArgs': ['parent',
                                                        'UIvisible'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MObject representing the new dependency node.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'UIvisible': [],
                                                                'parent': ['const',
                                                                           '&']},
                                             'types': {'UIvisible': 'bool',
                                                       'parent': 'MObject'}}],
                                 'emitAmbient': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieves the value of the "emitAmbient" attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setEmitAmbient',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the "emitAmbient" attribute of the volume light node.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'lightShape': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nRetrieves the "lightShape" attribute of the light. The shape can be one of the following.',
                                                 'inArgs': [],
                                                 'inverse': ('setLightShape',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The value of the "lightShape" attribute of the volume light node.',
                                                                'qualifiers': [],
                                                                'type': ('MFnVolumeLight',
                                                                         'MLightShape')},
                                                 'returnType': ('MFnVolumeLight',
                                                                'MLightShape'),
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                 'penumbraRamp': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the "penumbraRamp" attribute.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The penumbra ramp attribute',
                                                                  'qualifiers': [],
                                                                  'type': 'MRampAttribute'},
                                                   'returnType': 'MRampAttribute',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                 'setArc': [{'argInfo': {'arc': {'doc': 'value to which the attribute will be set.',
                                                                 'type': 'float'}},
                                             'args': [('arc',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the value of the "arc" attribute of a volume light node.',
                                             'inArgs': ['arc'],
                                             'inverse': ('arc', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'arc': ['const',
                                                                        '&']},
                                             'types': {'arc': 'float'}}],
                                 'setConeEndRadius': [{'argInfo': {'cone_end_radius': {'doc': 'value to which the attribute will be set.',
                                                                                       'type': 'float'}},
                                                       'args': [('cone_end_radius',
                                                                 'float',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the value of the "coneEndRadius" attribute of a volume light node.',
                                                       'inArgs': ['cone_end_radius'],
                                                       'inverse': ('coneEndRadius',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'cone_end_radius': ['const',
                                                                                              '&']},
                                                       'types': {'cone_end_radius': 'float'}}],
                                 'setEmitAmbient': [{'argInfo': {'emit_ambient': {'doc': 'value to which the attribute will be set.',
                                                                                  'type': 'bool'}},
                                                     'args': [('emit_ambient',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the value of the "emitAmbient" attribute of a volume light node.',
                                                     'inArgs': ['emit_ambient'],
                                                     'inverse': ('emitAmbient',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'emit_ambient': ['const',
                                                                                         '&']},
                                                     'types': {'emit_ambient': 'bool'}}],
                                 'setLightShape': [{'argInfo': {'light_shape': {'doc': 'value to which the attribute will be set.',
                                                                                'type': ('MFnVolumeLight',
                                                                                         'MLightShape')}},
                                                    'args': [('light_shape',
                                                              ('MFnVolumeLight',
                                                               'MLightShape'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the value of the "lightShape" attribute of a volume light node. The shape can be one of the following:',
                                                    'inArgs': ['light_shape'],
                                                    'inverse': ('lightShape',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'light_shape': ['const',
                                                                                       '&']},
                                                    'types': {'light_shape': ('MFnVolumeLight',
                                                                              'MLightShape')}}],
                                 'setShadowAngle': [{'argInfo': {'shadow_angle': {'doc': 'value to which the attribute will be set.',
                                                                                  'type': 'float'}},
                                                     'args': [('shadow_angle',
                                                               'float',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the value of the "shadowAngle" attribute of a volume light node. It\'s enabled only if the volume light direction is kDownAxis.',
                                                     'inArgs': ['shadow_angle'],
                                                     'inverse': ('shadowAngle',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'shadow_angle': ['const',
                                                                                         '&']},
                                                     'types': {'shadow_angle': 'float'}}],
                                 'setVolumeLightDirection': [{'argInfo': {'volume_light_direction': {'doc': 'value to which the attribute will be set.',
                                                                                                     'type': ('MFnVolumeLight',
                                                                                                              'MLightDirection')}},
                                                              'args': [('volume_light_direction',
                                                                        ('MFnVolumeLight',
                                                                         'MLightDirection'),
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nSets the value of the "volumeLightDirection" attribute of a volume light node. The shape can be one of the following.',
                                                              'inArgs': ['volume_light_direction'],
                                                              'inverse': ('volumeLightDirection',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'volume_light_direction': ['const',
                                                                                                            '&']},
                                                              'types': {'volume_light_direction': ('MFnVolumeLight',
                                                                                                   'MLightDirection')}}],
                                 'shadowAngle': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRetrieves the value of the "shadowAngle" attribute of a volume light node. This attribute represents an angular divergence from the direction vector of the light used to calculate soft shadows. It\'s enabled only if the volume light direction is kDownAxis.',
                                                  'inArgs': [],
                                                  'inverse': ('setShadowAngle',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the "shadowAngle" attribute of the light node.',
                                                                 'qualifiers': [],
                                                                 'type': 'float'},
                                                  'returnType': 'float',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFunction set type. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                 'volumeLightDirection': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nRetrieves the value of the "volumeLightDirection" attribute.',
                                                           'inArgs': [],
                                                           'inverse': ('setVolumeLightDirection',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The value of the "lightDirection" attribute of the volume light node.',
                                                                          'qualifiers': [],
                                                                          'type': ('MFnVolumeLight',
                                                                                   'MLightDirection')},
                                                           'returnType': ('MFnVolumeLight',
                                                                          'MLightDirection'),
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}]},
                     'pymelEnums': {'MLightDirection': "Enum('MLightDirection', [('outward', 0), ('kOutward', 0), ('inward', 1), ('kInward', 1), ('downAxis', 2), ('kDownAxis', 2)], multiKeys=True)",
                                    'MLightShape': "Enum('MLightShape', [('boxVolume', 0), ('kBoxVolume', 0), ('sphereVolume', 1), ('kSphereVolume', 1), ('cylinderVolume', 2), ('kCylinderVolume', 2), ('coneVolume', 3), ('kConeVolume', 3)], multiKeys=True)"},
                     'pymelMethods': {'arc': 'getArc',
                                      'coneEndRadius': 'getConeEndRadius',
                                      'emitAmbient': 'getEmitAmbient',
                                      'lightShape': 'getLightShape',
                                      'shadowAngle': 'getShadowAngle',
                                      'volumeLightDirection': 'getVolumeLightDirection'}},
  'MFnVortexField': {'enums': {},
                     'invertibles': [('setAxis', 'axis')],
                     'methods': {'axis': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "\nReturns the axis around which the vortex field exerts it's force.",
                                           'inArgs': [],
                                           'inverse': ('setAxis', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A vector representing an axis.',
                                                          'qualifiers': [],
                                                          'type': 'MVector'},
                                           'returnType': 'MVector',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                                 'setAxis': [{'argInfo': {'axisVector': {'doc': 'A vector representing an axis.',
                                                                         'type': 'MVector'}},
                                              'args': [('axisVector',
                                                        'MVector',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\nSets the axis around which the vortex field exerts it's force.",
                                              'inArgs': ['axisVector'],
                                              'inverse': ('axis', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'axisVector': ['const',
                                                                                '&']},
                                              'types': {'axisVector': 'MVector'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nFunction set type. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'axis': 'getAxis'}},
  'MFnWeightGeometryFilter': {'enums': {},
                              'methods': {'getWeightPlugStrings': [{'argInfo': {'list': {'doc': 'selection list that contains components ',
                                                                                         'type': 'MSelectionList'},
                                                                                'plugStringArray': {'doc': 'string array containing the names of the plugs on this node that correspond to the components in the selection list; each of the plugs is put in a separate string',
                                                                                                    'type': 'MStringArray'}},
                                                                    'args': [('list',
                                                                              'MSelectionList',
                                                                              'in'),
                                                                             ('plugStringArray',
                                                                              'MStringArray',
                                                                              'out')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nSet the plugStringArray argument to contain the names of the plugs on this node that correspond to the components in the selection list. The operation will fail if none of the items in the selection list correspond to components weighted by this cluster.',
                                                                    'inArgs': ['list'],
                                                                    'outArgs': ['plugStringArray'],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'list': ['const',
                                                                                                '&'],
                                                                                       'plugStringArray': ['&']},
                                                                    'types': {'list': 'MSelectionList',
                                                                              'plugStringArray': 'MStringArray'}},
                                                                   {'argInfo': {'list': {'doc': 'selection list that contains components ',
                                                                                         'type': 'MSelectionList'},
                                                                                'plugStrings': {'doc': 'string containing the names of the plugs on this node that correspond to the components in the selection list',
                                                                                                'type': 'MString'}},
                                                                    'args': [('list',
                                                                              'MSelectionList',
                                                                              'out'),
                                                                             ('plugStrings',
                                                                              'MString',
                                                                              'out')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                                    'inArgs': [],
                                                                    'outArgs': ['list',
                                                                                'plugStrings'],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'list': ['const',
                                                                                                '&'],
                                                                                       'plugStrings': ['&']},
                                                                    'types': {'list': 'MSelectionList',
                                                                              'plugStrings': 'MString'}}],
                                          'getWeights': [{'argInfo': {'components': {'doc': 'the components whose weights are requested ',
                                                                                     'type': 'MObject'},
                                                                      'index': {'doc': 'the plug index corresponding to the shape that has the components ',
                                                                                'type': 'uint'},
                                                                      'weights': {'doc': 'the weight values of the components',
                                                                                  'type': 'MFloatArray'}},
                                                          'args': [('index',
                                                                    'uint',
                                                                    'in'),
                                                                   ('components',
                                                                    'MObject',
                                                                    'out'),
                                                                   ('weights',
                                                                    'MFloatArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGets the weights of the components that correspond to the geometry at the specified plug index.',
                                                          'inArgs': ['index'],
                                                          'outArgs': ['components',
                                                                      'weights'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'components': ['const',
                                                                                            '&'],
                                                                             'index': ['unsigned'],
                                                                             'weights': ['&']},
                                                          'types': {'components': 'MObject',
                                                                    'index': 'uint',
                                                                    'weights': 'MFloatArray'}},
                                                         {'argInfo': {'components': {'doc': 'the components whose weights are requested ',
                                                                                     'type': 'MObject'},
                                                                      'path': {'doc': 'the path of the DAG object that has the components ',
                                                                               'type': 'MDagPath'},
                                                                      'weights': {'doc': 'the weight values of the components',
                                                                                  'type': 'MFloatArray'}},
                                                          'args': [('path',
                                                                    'MDagPath',
                                                                    'in'),
                                                                   ('components',
                                                                    'MObject',
                                                                    'in'),
                                                                   ('weights',
                                                                    'MFloatArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGets the weights of the components that correspond to the geometry whose DAG path is specified.',
                                                          'inArgs': ['path',
                                                                     'components'],
                                                          'outArgs': ['weights'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'components': ['const',
                                                                                            '&'],
                                                                             'path': ['const',
                                                                                      '&'],
                                                                             'weights': ['&']},
                                                          'types': {'components': 'MObject',
                                                                    'path': 'MDagPath',
                                                                    'weights': 'MFloatArray'}}],
                                          'setWeight': [{'argInfo': {'components': {'doc': 'the components of the object ',
                                                                                    'type': 'MObject'},
                                                                     'index': {'doc': 'the plug index for the specified shape ',
                                                                               'type': 'uint'},
                                                                     'oldValues': {'doc': 'an array of old values for the components',
                                                                                   'type': 'MFloatArray'},
                                                                     'path': {'doc': "the DAG path for the object whose components' weights are being set ",
                                                                              'type': 'MDagPath'},
                                                                     'weight': {'doc': 'weight value for the components ',
                                                                                'type': 'float'}},
                                                         'args': [('path',
                                                                   'MDagPath',
                                                                   'in'),
                                                                  ('index',
                                                                   'uint',
                                                                   'in'),
                                                                  ('components',
                                                                   'MObject',
                                                                   'in'),
                                                                  ('weight',
                                                                   'float',
                                                                   'in'),
                                                                  ('oldValues',
                                                                   'MFloatArray',
                                                                   'in')],
                                                         'defaults': {'oldValues': None},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the weights of the specified components of the object whose DAG path is specified.',
                                                         'inArgs': ['path',
                                                                    'index',
                                                                    'components',
                                                                    'weight',
                                                                    'oldValues'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'components': ['const',
                                                                                           '&'],
                                                                            'index': ['unsigned'],
                                                                            'oldValues': ['*'],
                                                                            'path': ['const',
                                                                                     '&'],
                                                                            'weight': []},
                                                         'types': {'components': 'MObject',
                                                                   'index': 'uint',
                                                                   'oldValues': 'MFloatArray',
                                                                   'path': 'MDagPath',
                                                                   'weight': 'float'}},
                                                        {'argInfo': {'components': {'doc': 'the components of the object ',
                                                                                    'type': 'MObject'},
                                                                     'oldValues': {'doc': 'an array of old values for the components',
                                                                                   'type': 'MFloatArray'},
                                                                     'path': {'doc': "the DAG path for the object whose components' weights are being set ",
                                                                              'type': 'MDagPath'},
                                                                     'weight': {'doc': 'weight value for the components ',
                                                                                'type': 'float'}},
                                                         'args': [('path',
                                                                   'MDagPath',
                                                                   'in'),
                                                                  ('components',
                                                                   'MObject',
                                                                   'in'),
                                                                  ('weight',
                                                                   'float',
                                                                   'in'),
                                                                  ('oldValues',
                                                                   'MFloatArray',
                                                                   'in')],
                                                         'defaults': {'oldValues': None},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the weights of the specified components of the object whose DAG path is specified.',
                                                         'inArgs': ['path',
                                                                    'components',
                                                                    'weight',
                                                                    'oldValues'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'components': ['const',
                                                                                           '&'],
                                                                            'oldValues': ['*'],
                                                                            'path': ['const',
                                                                                     '&'],
                                                                            'weight': []},
                                                         'types': {'components': 'MObject',
                                                                   'oldValues': 'MFloatArray',
                                                                   'path': 'MDagPath',
                                                                   'weight': 'float'}},
                                                        {'argInfo': {'components': {'doc': 'the components of the object ',
                                                                                    'type': 'MObject'},
                                                                     'index': {'doc': 'the plug index for the specified shape ',
                                                                               'type': 'uint'},
                                                                     'path': {'doc': "the DAG path for the object whose components' weights are being set ",
                                                                              'type': 'MDagPath'},
                                                                     'values': {'doc': 'the value array of the components',
                                                                                'type': 'MFloatArray'}},
                                                         'args': [('path',
                                                                   'MDagPath',
                                                                   'in'),
                                                                  ('index',
                                                                   'uint',
                                                                   'in'),
                                                                  ('components',
                                                                   'MObject',
                                                                   'in'),
                                                                  ('values',
                                                                   'MFloatArray',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the weights of the specified components of the object whose DAG path is specified.',
                                                         'inArgs': ['path',
                                                                    'index',
                                                                    'components',
                                                                    'values'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'components': ['const',
                                                                                           '&'],
                                                                            'index': ['unsigned'],
                                                                            'path': ['const',
                                                                                     '&'],
                                                                            'values': ['&']},
                                                         'types': {'components': 'MObject',
                                                                   'index': 'uint',
                                                                   'path': 'MDagPath',
                                                                   'values': 'MFloatArray'}},
                                                        {'argInfo': {'components': {'doc': 'the components of the object ',
                                                                                    'type': 'MObject'},
                                                                     'path': {'doc': "the DAG path for the object whose components' weights are being set ",
                                                                              'type': 'MDagPath'},
                                                                     'values': {'doc': 'the value array of the components',
                                                                                'type': 'MFloatArray'}},
                                                         'args': [('path',
                                                                   'MDagPath',
                                                                   'in'),
                                                                  ('components',
                                                                   'MObject',
                                                                   'in'),
                                                                  ('values',
                                                                   'MFloatArray',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the weights of the specified components of the object whose DAG path is specified.',
                                                         'inArgs': ['path',
                                                                    'components',
                                                                    'values'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'components': ['const',
                                                                                           '&'],
                                                                            'path': ['const',
                                                                                     '&'],
                                                                            'values': ['&']},
                                                         'types': {'components': 'MObject',
                                                                   'path': 'MDagPath',
                                                                   'values': 'MFloatArray'}}],
                                          'type': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nFunction set type. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': ('MFn',
                                                                            'Type')},
                                                    'returnType': ('MFn',
                                                                   'Type'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                          'weightPlugStrings': [{'argInfo': {'list': {'doc': 'selection list that contains components ',
                                                                                      'type': 'MSelectionList'}},
                                                                 'args': [('list',
                                                                           'MSelectionList',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nSets the plugStrings argument to be a string (separated by spaces) containing the names of the plugs on this node that correspond to the components in the selection list. The method can be useful in conjunction with setting keys on a number of plugs. The operation will fail if none of the items in the selection list correspond to components weighted by this cluster.',
                                                                 'inArgs': ['list'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'A string containing the names of the plugs on this node that correspond to the components in the selection list',
                                                                                'qualifiers': [],
                                                                                'type': 'MString'},
                                                                 'returnType': 'MString',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'list': ['const',
                                                                                             '&']},
                                                                 'types': {'list': 'MSelectionList'}}]},
                              'pymelEnums': {}},
  'MFnWireDeformer': {'enums': {},
                      'invertibles': [('setCrossingEffect',
                                       'crossingEffect'),
                                      ('setLocalIntensity',
                                       'localIntensity'),
                                      ('setWireDropOffDistance',
                                       'wireDropOffDistance'),
                                      ('setEnvelope', 'envelope'),
                                      ('setRotation', 'rotation'),
                                      ('setHoldingShape', 'holdingShape'),
                                      ('setWireScale', 'wireScale'),
                                      ('setDropoffLocator',
                                       'getDropoffLocator')],
                      'methods': {'addGeometry': [{'argInfo': {'object': {'doc': 'the geometry',
                                                                          'type': 'MObject'}},
                                                   'args': [('object',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nAdds a piece of geometry to the deformation.',
                                                   'inArgs': ['object'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'object': ['const',
                                                                                 '&']},
                                                   'types': {'object': 'MObject'}}],
                                  'addWire': [{'argInfo': {'object': {'doc': 'the new wire',
                                                                      'type': 'MObject'}},
                                               'args': [('object',
                                                         'MObject',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nAdds a new wire curve to the deformation.',
                                               'inArgs': ['object'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'object': ['const',
                                                                             '&']},
                                               'types': {'object': 'MObject'}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nClass name. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'create': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "\nCreates a new wire deformer. This function set's object is set to be the new wire deformer node.",
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Returns a handle to the new deformer',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                  'crossingEffect': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturns the crossing effect for this wire deformer.',
                                                      'inArgs': [],
                                                      'inverse': ('setCrossingEffect',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The crossing effect value',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                  'envelope': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the envelope for this deformer.',
                                                'inArgs': [],
                                                'inverse': ('setEnvelope',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The envelope value',
                                                               'qualifiers': [],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                  'getAffectedGeometry': [{'argInfo': {'objects': {'doc': 'storage for the returned array',
                                                                                   'type': 'MObjectArray'}},
                                                           'args': [('objects',
                                                                     'MObjectArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nThe geometry affected by this deformer is packed into the provided list of MObjects. Each of the MObjects will be a DAG node that has geometry.',
                                                           'inArgs': [],
                                                           'outArgs': ['objects'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'objects': ['&']},
                                                           'types': {'objects': 'MObjectArray'}}],
                                  'getDropoffLocator': [{'argInfo': {'locatorIndex': {'doc': 'index of the locator on the given wire ',
                                                                                      'type': 'uint'},
                                                                     'param': {'doc': 'storage for the param value along the curve that the locator is positioned at ',
                                                                               'type': 'float'},
                                                                     'percentage': {'doc': 'storage for the percentage value of the locator',
                                                                                    'type': 'float'},
                                                                     'wireIndex': {'doc': 'index of the wire curve ',
                                                                                   'type': 'uint'}},
                                                         'args': [('wireIndex',
                                                                   'uint',
                                                                   'in'),
                                                                  ('locatorIndex',
                                                                   'uint',
                                                                   'in'),
                                                                  ('param',
                                                                   'float',
                                                                   'out'),
                                                                  ('percentage',
                                                                   'float',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nGets the parameters of a drop off locator.',
                                                         'inArgs': ['wireIndex',
                                                                    'locatorIndex'],
                                                         'inverse': ('setDropoffLocator',
                                                                     False),
                                                         'outArgs': ['param',
                                                                     'percentage'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'locatorIndex': ['unsigned'],
                                                                            'param': ['&'],
                                                                            'percentage': ['&'],
                                                                            'wireIndex': ['unsigned']},
                                                         'types': {'locatorIndex': 'uint',
                                                                   'param': 'float',
                                                                   'percentage': 'float',
                                                                   'wireIndex': 'uint'}}],
                                  'holdingShape': [{'argInfo': {'wireIndex': {'doc': 'index of wire to get the holding shape for ',
                                                                              'type': 'uint'}},
                                                    'args': [('wireIndex',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the holding shape for the given wire. The holding shape may be a nurbs curve or a nurbs surface. If the given wire does not have a holding shape, then a null  MObject  handle will be returned.',
                                                    'inArgs': ['wireIndex'],
                                                    'inverse': ('setHoldingShape',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Return status',
                                                                   'qualifiers': [],
                                                                   'type': 'MObject'},
                                                    'returnType': 'MObject',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'wireIndex': ['unsigned']},
                                                    'types': {'wireIndex': 'uint'}}],
                                  'localIntensity': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturns the local intensity for this wire deformer.',
                                                      'inArgs': [],
                                                      'inverse': ('setLocalIntensity',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The local intensity value',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                  'numDropoffLocators': [{'argInfo': {'wireIndex': {'doc': 'the index of the wire curve to query ',
                                                                                    'type': 'uint'}},
                                                          'args': [('wireIndex',
                                                                    'uint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the number of drop off locators.',
                                                          'inArgs': ['wireIndex'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The number of drop off locators for the given curve',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'wireIndex': ['unsigned']},
                                                          'types': {'wireIndex': 'uint'}}],
                                  'numWires': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nreturns the number of wire curves connected to this deformer.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of wires',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                  'removeGeometry': [{'argInfo': {'object': {'doc': 'the geometry',
                                                                             'type': 'MObject'}},
                                                      'args': [('object',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nRemoves a piece of geometry from the deformation.',
                                                      'inArgs': ['object'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'object': ['const',
                                                                                    '&']},
                                                      'types': {'object': 'MObject'}}],
                                  'rotation': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the rotation value for this deformer.',
                                                'inArgs': [],
                                                'inverse': ('setRotation',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The rotation value',
                                                               'qualifiers': [],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                  'setCrossingEffect': [{'argInfo': {'crossingEffect': {'doc': 'New crossing effect value',
                                                                                        'type': 'float'}},
                                                         'args': [('crossingEffect',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the crossing effect for this wire deformer.',
                                                         'inArgs': ['crossingEffect'],
                                                         'inverse': ('crossingEffect',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'crossingEffect': []},
                                                         'types': {'crossingEffect': 'float'}}],
                                  'setDropoffLocator': [{'argInfo': {'locatorIndex': {'doc': 'index of the locator on the given wire ',
                                                                                      'type': 'uint'},
                                                                     'param': {'doc': 'new param value along the curve at which to position the locator ',
                                                                               'type': 'float'},
                                                                     'percentage': {'doc': 'percentage of the drop off distance applied',
                                                                                    'type': 'float'},
                                                                     'wireIndex': {'doc': 'index of the wire curve ',
                                                                                   'type': 'uint'}},
                                                         'args': [('wireIndex',
                                                                   'uint',
                                                                   'in'),
                                                                  ('locatorIndex',
                                                                   'uint',
                                                                   'in'),
                                                                  ('param',
                                                                   'float',
                                                                   'in'),
                                                                  ('percentage',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the parameters of a drop off locator.',
                                                         'inArgs': ['wireIndex',
                                                                    'locatorIndex',
                                                                    'param',
                                                                    'percentage'],
                                                         'inverse': ('getDropoffLocator',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'locatorIndex': ['unsigned'],
                                                                            'param': [],
                                                                            'percentage': [],
                                                                            'wireIndex': ['unsigned']},
                                                         'types': {'locatorIndex': 'uint',
                                                                   'param': 'float',
                                                                   'percentage': 'float',
                                                                   'wireIndex': 'uint'}}],
                                  'setEnvelope': [{'argInfo': {'envelope': {'doc': 'envelope value',
                                                                            'type': 'float'}},
                                                   'args': [('envelope',
                                                             'float',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the envelope for this deformer.',
                                                   'inArgs': ['envelope'],
                                                   'inverse': ('envelope',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'envelope': []},
                                                   'types': {'envelope': 'float'}}],
                                  'setHoldingShape': [{'argInfo': {'holdingShape': {'doc': 'nurbs curve or surface to use as holding shape',
                                                                                    'type': 'MObject'},
                                                                   'wireIndex': {'doc': 'index of wire to set the holding shape for ',
                                                                                 'type': 'uint'}},
                                                       'args': [('wireIndex',
                                                                 'uint',
                                                                 'in'),
                                                                ('holdingShape',
                                                                 'MObject',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets the holding shape for the given wire. The holding shape may be a nurbs curve or a nurbs surface.',
                                                       'inArgs': ['wireIndex',
                                                                  'holdingShape'],
                                                       'inverse': ('holdingShape',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'holdingShape': [],
                                                                          'wireIndex': ['unsigned']},
                                                       'types': {'holdingShape': 'MObject',
                                                                 'wireIndex': 'uint'}}],
                                  'setLocalIntensity': [{'argInfo': {'localIntensity': {'doc': 'New local intensity value',
                                                                                        'type': 'float'}},
                                                         'args': [('localIntensity',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nSets the local intensity for this wire deformer.',
                                                         'inArgs': ['localIntensity'],
                                                         'inverse': ('localIntensity',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'localIntensity': []},
                                                         'types': {'localIntensity': 'float'}}],
                                  'setRotation': [{'argInfo': {'rotation': {'doc': 'new rotation value',
                                                                            'type': 'float'}},
                                                   'args': [('rotation',
                                                             'float',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the rotation value for this deformer.',
                                                   'inArgs': ['rotation'],
                                                   'inverse': ('rotation',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'rotation': []},
                                                   'types': {'rotation': 'float'}}],
                                  'setWireDropOffDistance': [{'argInfo': {'dropOff': {'doc': 'new drop off value',
                                                                                      'type': 'float'},
                                                                          'wireIndex': {'doc': 'index of wire to set the drop off distance for ',
                                                                                        'type': 'uint'}},
                                                              'args': [('wireIndex',
                                                                        'uint',
                                                                        'in'),
                                                                       ('dropOff',
                                                                        'float',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the drop off distance of the wire at the given index. Increasing this value will give the wire a greater area of influence.',
                                                              'inArgs': ['wireIndex',
                                                                         'dropOff'],
                                                              'inverse': ('wireDropOffDistance',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'dropOff': [],
                                                                                 'wireIndex': ['unsigned']},
                                                              'types': {'dropOff': 'float',
                                                                        'wireIndex': 'uint'}}],
                                  'setWireScale': [{'argInfo': {'scale': {'doc': 'new scale value',
                                                                          'type': 'float'},
                                                                'wireIndex': {'doc': 'index of wire to set the drop off distance for ',
                                                                              'type': 'uint'}},
                                                    'args': [('wireIndex',
                                                              'uint',
                                                              'in'),
                                                             ('scale',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets the radial scale value of the wire at the given index. The scale value affects how the wire modifies the geometry in its area of influence. A value of between 0.0 and 1.0 causes the wire to pull the surrounding geometry points towards itself. A value of greater than one causes the wire to repulse the geometry points around it. A value of exactly 1.0 causes the wire to neither pull nor push the points around it.',
                                                    'inArgs': ['wireIndex',
                                                               'scale'],
                                                    'inverse': ('wireScale',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'scale': [],
                                                                       'wireIndex': ['unsigned']},
                                                    'types': {'scale': 'float',
                                                              'wireIndex': 'uint'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFunction set type. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                  'wire': [{'argInfo': {'wireIndex': {'doc': 'index of wire to return ',
                                                                      'type': 'uint'}},
                                            'args': [('wireIndex',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturn the wire at the given index. The returned object will be a nurbs curve shape suitable for use with the  MFnNurbsCurve  function set.',
                                            'inArgs': ['wireIndex'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A handle to the given wire curve',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'wireIndex': ['unsigned']},
                                            'types': {'wireIndex': 'uint'}}],
                                  'wireDropOffDistance': [{'argInfo': {'wireIndex': {'doc': 'index of wire to return the drop off distance for ',
                                                                                     'type': 'uint'}},
                                                           'args': [('wireIndex',
                                                                     'uint',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nReturn the drop off distance of the wire at the given index. Increasing this value will give the wire a greater area of influence.',
                                                           'inArgs': ['wireIndex'],
                                                           'inverse': ('setWireDropOffDistance',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The drop off distance',
                                                                          'qualifiers': [],
                                                                          'type': 'float'},
                                                           'returnType': 'float',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'wireIndex': ['unsigned']},
                                                           'types': {'wireIndex': 'uint'}}],
                                  'wireScale': [{'argInfo': {'wireIndex': {'doc': 'index of wire to return the scale value for ',
                                                                           'type': 'uint'}},
                                                 'args': [('wireIndex',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturn the radial scale of the wire at the given index. The scale value affects how the wire modifies the geometry in its area of influence. A value of between 0.0 and 1.0 causes the wire to pull the surrounding geometry points towards itself. A value of greater than one causes the wire to repulse the geometry points around it. A value of exactly 1.0 causes the wire to neither pull nor push the points around it.',
                                                 'inArgs': ['wireIndex'],
                                                 'inverse': ('setWireScale',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The radial scale value',
                                                                'qualifiers': [],
                                                                'type': 'float'},
                                                 'returnType': 'float',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'wireIndex': ['unsigned']},
                                                 'types': {'wireIndex': 'uint'}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'crossingEffect': 'getCrossingEffect',
                                       'envelope': 'getEnvelope',
                                       'holdingShape': 'getHoldingShape',
                                       'localIntensity': 'getLocalIntensity',
                                       'rotation': 'getRotation',
                                       'wireDropOffDistance': 'getWireDropOffDistance',
                                       'wireScale': 'getWireScale'}},
  'MGLFunctionTable': {'enums': {'MGLversion': {'valueDocs': {'kMGL_Version11': 'GL 1.1.',
                                                              'kMGL_Version12': 'GL 1.2.',
                                                              'kMGL_Version121': 'GL 1.2.1.',
                                                              'kMGL_Version13': 'GL 1.3.1.',
                                                              'kMGL_Version14': 'GL 1.4.1.',
                                                              'kMGL_Version15': 'GL 1.5.',
                                                              'kMGL_Version20': 'GL 2.0.',
                                                              'version11': 'GL 1.1.',
                                                              'version12': 'GL 1.2.',
                                                              'version121': 'GL 1.2.1.',
                                                              'version13': 'GL 1.3.1.',
                                                              'version14': 'GL 1.4.1.',
                                                              'version15': 'GL 1.5.',
                                                              'version20': 'GL 2.0.'},
                                                'values': "Enum('MGLversion', {'kMGL_Version11': 0, 'kMGL_Version12': 1, 'kMGL_Version121': 2, 'kMGL_Version13': 3, 'kMGL_Version14': 4, 'kMGL_Version15': 5, 'kMGL_Version20': 6})"}},
                       'methods': {'extensionExists': [{'argInfo': {'extension': {'doc': 'Extension enumeration.',
                                                                                  'type': ('MGLFunctionTable',
                                                                                           'MGLExtension')}},
                                                        'args': [('extension',
                                                                  ('MGLFunctionTable',
                                                                   'MGLExtension'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nProvides information as to whether a given OpenGL extension exists. That is, the extension is reported to be supported.',
                                                        'inArgs': ['extension'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'true if the extension exists, false otherwise. ',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'extension': []},
                                                        'types': {'extension': ('MGLFunctionTable',
                                                                                'MGLExtension')}}],
                                   'maxTextureSize': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGet information about the maximum texture size.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                   'maxVertexAttributes': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nGet information about the maximum number of vertex attributes available.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'int'},
                                                            'returnType': 'int',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                   'numTexImageUnits': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGet information about the maximum number of texture image units available.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                   'numTexInterpolants': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nGet information about the maximum number of texture interpolants.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                   'numTexUnits': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet information about the maximum number of texture units. This may not be the same as the number of interpolants available.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                       'pymelEnums': {'MGLversion': "Enum('MGLversion', [('version11', 0), ('kMGL_Version11', 0), ('version12', 1), ('kMGL_Version12', 1), ('version121', 2), ('kMGL_Version121', 2), ('version13', 3), ('kMGL_Version13', 3), ('version14', 4), ('kMGL_Version14', 4), ('version15', 5), ('kMGL_Version15', 5), ('version20', 6), ('kMGL_Version20', 6)], multiKeys=True)"}},
  'MGeometryData': {'enums': {'DataType': {'valueDocs': {'APISupported': 'Separator to indicate native draw API supported types.',
                                                         'biNormal': 'Bi-normal vector.',
                                                         'color': 'Color tuple.',
                                                         'colorMask': 'Mapped, unmapped color mask.',
                                                         'invalidDataType': 'Invalid data type (default value).',
                                                         'kAPISupported': 'Separator to indicate native draw API supported types.',
                                                         'kBiNormal': 'Bi-normal vector.',
                                                         'kColor': 'Color tuple.',
                                                         'kColorMask': 'Mapped, unmapped color mask.',
                                                         'kInvalidDataType': 'Invalid data type (default value).',
                                                         'kMaxDataTypeIndex': 'Valid entries are < kMaxDataTypeIndex.',
                                                         'kNormal': 'Normal vector.',
                                                         'kPosition': 'Position vector.',
                                                         'kPrimitiveCenter': 'Center of primitive.',
                                                         'kTangent': 'Tangent vector.',
                                                         'kTexCoord': 'Texture coordinate tuple.',
                                                         'kUserData': 'Arbitrary "user data".',
                                                         'kVelocity': 'Velocity vector.',
                                                         'kWeight': 'Vertex weighting data.',
                                                         'maxDataTypeIndex': 'Valid entries are < kMaxDataTypeIndex.',
                                                         'normal': 'Normal vector.',
                                                         'position': 'Position vector.',
                                                         'primitiveCenter': 'Center of primitive.',
                                                         'tangent': 'Tangent vector.',
                                                         'texCoord': 'Texture coordinate tuple.',
                                                         'userData': 'Arbitrary "user data".',
                                                         'velocity': 'Velocity vector.',
                                                         'weight': 'Vertex weighting data.'},
                                           'values': "Enum('DataType', {'kInvalidDataType': 0, 'kPosition': 1, 'kNormal': 2, 'kTexCoord': 3, 'kColor': 4, 'kWeight': 5, 'kAPISupported': 6, 'kTangent': 7, 'kBiNormal': 8, 'kVelocity': 9, 'kPrimitiveCenter': 10, 'kColorMask': 11, 'kUserData': 12, 'kMaxDataTypeIndex': 13})"},
                              'ElementSize': {'valueDocs': {'four': '4-tuple',
                                                            'invalidElementSize': 'Invalid element size.',
                                                            'kFour': '4-tuple',
                                                            'kInvalidElementSize': 'Invalid element size.',
                                                            'kOne': 'Single value.',
                                                            'kThree': '3-tuple',
                                                            'kTwo': '2-tuple',
                                                            'one': 'Single value.',
                                                            'three': '3-tuple',
                                                            'two': '2-tuple'},
                                              'values': "Enum('ElementSize', {'kInvalidElementSize': 0, 'kOne': 1, 'kTwo': 2, 'kThree': 3, 'kFour': 4})"},
                              'ElementType': {'valueDocs': {'char': 'Signed char.',
                                                            'double': 'IEEE double precision floating point.',
                                                            'float': 'IEEE single precision floating point.',
                                                            'int16': 'Signed 16-bit integer.',
                                                            'int32': 'Signed 32-bit integer.',
                                                            'invalidElementType': 'Invalid element type (default value).',
                                                            'kChar': 'Signed char.',
                                                            'kDouble': 'IEEE double precision floating point.',
                                                            'kFloat': 'IEEE single precision floating point.',
                                                            'kInt16': 'Signed 16-bit integer.',
                                                            'kInt32': 'Signed 32-bit integer.',
                                                            'kInvalidElementType': 'Invalid element type (default value).',
                                                            'kUnsignedChar': 'Unsigned char.',
                                                            'kUnsignedInt16': 'Unsigned 16-bit integer.',
                                                            'kUnsignedInt32': 'Unsigned 32-bit integer.',
                                                            'unsignedChar': 'Unsigned char.',
                                                            'unsignedInt16': 'Unsigned 16-bit integer.',
                                                            'unsignedInt32': 'Unsigned 32-bit integer.'},
                                              'values': "Enum('ElementType', {'kInvalidElementType': -1, 'kFloat': 0, 'kDouble': 1, 'kChar': 2, 'kUnsignedChar': 3, 'kInt16': 4, 'kUnsignedInt16': 5, 'kInt32': 6, 'kUnsignedInt32': 7})"}},
                    'invertibles': [('setCollectionNumber',
                                     'collectionNumber'),
                                    ('setObjectOwnsData', 'objectOwnsData')],
                    'methods': {'collectionNumber': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the collection number of the data. Collection numbers are zero-based.',
                                                      'inArgs': [],
                                                      'inverse': ('setCollectionNumber',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                'data': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nRetrieve a pointer to the internal data',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'dataType': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the data type for the data.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MGeometryData',
                                                                      'DataType')},
                                              'returnType': ('MGeometryData',
                                                             'DataType'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                'elementCount': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn element count.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Element count. 0 is returned on error. ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                'elementSize': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn element size.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MGeometryData',
                                                                         'ElementSize')},
                                                 'returnType': ('MGeometryData',
                                                                'ElementSize'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                'elementType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the data type.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': ('MGeometryData',
                                                                         'ElementType')},
                                                 'returnType': ('MGeometryData',
                                                                'ElementType'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                'elementTypeSize': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn the element type size',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                'objectName': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the logical name of the geometry',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                'objectOwnsData': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn if the  MGeometryData  object owns the internal data or not.',
                                                    'inArgs': [],
                                                    'inverse': ('setObjectOwnsData',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                'setCollectionNumber': [{'argInfo': {'collectionNumber': {'doc': 'The number to use ',
                                                                                          'type': 'int'}},
                                                         'args': [('collectionNumber',
                                                                   'int',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSet the collection number for the object. Numbers less than 0 are invalid collection numbers.',
                                                         'inArgs': ['collectionNumber'],
                                                         'inverse': ('collectionNumber',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'collectionNumber': []},
                                                         'types': {'collectionNumber': 'int'}}],
                                'setObjectOwnsData': [{'argInfo': {'value': {'doc': 'ownership flag to set to. ',
                                                                             'type': 'bool'}},
                                                       'args': [('value',
                                                                 'bool',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet ownship of the interal data.',
                                                       'inArgs': ['value'],
                                                       'inverse': ('objectOwnsData',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'value': []},
                                                       'types': {'value': 'bool'}}],
                                'uniqueID': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the per session unique identifier',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                    'pymelEnums': {'DataType': "Enum('DataType', [('invalidDataType', 0), ('kInvalidDataType', 0), ('position', 1), ('kPosition', 1), ('normal', 2), ('kNormal', 2), ('texCoord', 3), ('kTexCoord', 3), ('color', 4), ('kColor', 4), ('weight', 5), ('kWeight', 5), ('APISupported', 6), ('kAPISupported', 6), ('tangent', 7), ('kTangent', 7), ('biNormal', 8), ('kBiNormal', 8), ('velocity', 9), ('kVelocity', 9), ('primitiveCenter', 10), ('kPrimitiveCenter', 10), ('colorMask', 11), ('kColorMask', 11), ('userData', 12), ('kUserData', 12), ('maxDataTypeIndex', 13), ('kMaxDataTypeIndex', 13)], multiKeys=True)",
                                   'ElementSize': "Enum('ElementSize', [('invalidElementSize', 0), ('kInvalidElementSize', 0), ('one', 1), ('kOne', 1), ('two', 2), ('kTwo', 2), ('three', 3), ('kThree', 3), ('four', 4), ('kFour', 4)], multiKeys=True)",
                                   'ElementType': "Enum('ElementType', [('invalidElementType', -1), ('kInvalidElementType', -1), ('float', 0), ('kFloat', 0), ('double', 1), ('kDouble', 1), ('char', 2), ('kChar', 2), ('unsignedChar', 3), ('kUnsignedChar', 3), ('int16', 4), ('kInt16', 4), ('unsignedInt16', 5), ('kUnsignedInt16', 5), ('int32', 6), ('kInt32', 6), ('unsignedInt32', 7), ('kUnsignedInt32', 7)], multiKeys=True)"},
                    'pymelMethods': {'collectionNumber': 'getCollectionNumber',
                                     'objectOwnsData': 'getObjectOwnsData'}},
  'MGeometryLegacy': {'enums': {},
                      'methods': {'binormal': [{'argInfo': {'name': {'doc': 'the name of the uv set binormal data should be returned for',
                                                                     'type': 'MString'}},
                                                'args': [('name',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet a binormal set by name.',
                                                'inArgs': ['name'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The binormal data (which may be empty). ',
                                                               'qualifiers': [],
                                                               'type': 'MGeometryData'},
                                                'returnType': 'MGeometryData',
                                                'static': False,
                                                'typeQualifiers': {'name': ['const',
                                                                            '&']},
                                                'types': {'name': 'MString'}}],
                                  'color': [{'argInfo': {'name': {'doc': 'the name of the set to return',
                                                                  'type': 'MString'}},
                                             'args': [('name',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet a color set by name.',
                                             'inArgs': ['name'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The color data (which may be empty). ',
                                                            'qualifiers': [],
                                                            'type': 'MGeometryData'},
                                             'returnType': 'MGeometryData',
                                             'static': False,
                                             'typeQualifiers': {'name': ['const',
                                                                         '&']},
                                             'types': {'name': 'MString'}}],
                                  'componentId': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the Maya component id data for this surface. This array allows you to correlate  MGeometryLegacy  entries with the corresponding component on the Maya surface (e.g. for meshes, this array will contains the vertex id).',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MGeometryData'},
                                                   'returnType': 'MGeometryData',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                  'data': [{'argInfo': {'name': {'doc': 'the name of the data set requested',
                                                                 'type': 'MString'},
                                                        'what': {'doc': 'the type of data requested ',
                                                                 'type': ('MGeometryData',
                                                                          'DataType')}},
                                            'args': [('what',
                                                      ('MGeometryData',
                                                       'DataType'),
                                                      'in'),
                                                     ('name',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGet arbitrary surface data by name.',
                                            'inArgs': ['what', 'name'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The geometry data (which may be empty). ',
                                                           'qualifiers': [],
                                                           'type': 'MGeometryData'},
                                            'returnType': 'MGeometryData',
                                            'static': False,
                                            'typeQualifiers': {'name': ['const',
                                                                        '&'],
                                                               'what': []},
                                            'types': {'name': 'MString',
                                                      'what': ('MGeometryData',
                                                               'DataType')}}],
                                  'normal': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the normal data for this surface.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The normal data (which may be empty). ',
                                                             'qualifiers': [],
                                                             'type': 'MGeometryData'},
                                              'returnType': 'MGeometryData',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                  'position': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the position data for this surface.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The position data (which may be empty). ',
                                                               'qualifiers': [],
                                                               'type': 'MGeometryData'},
                                                'returnType': 'MGeometryData',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                  'primitiveArray': [{'argInfo': {'arrayNumber': {'doc': 'Number of the index data to retrieve. Must be in the range 0 to primitiveArrayCount() - 1.',
                                                                                  'type': 'uint'}},
                                                      'args': [('arrayNumber',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the primitive indexing data for this surface.',
                                                      'inArgs': ['arrayNumber'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Primitive data structure, which may be empty. ',
                                                                     'qualifiers': [],
                                                                     'type': 'MGeometryPrimitive'},
                                                      'returnType': 'MGeometryPrimitive',
                                                      'static': False,
                                                      'typeQualifiers': {'arrayNumber': ['unsigned']},
                                                      'types': {'arrayNumber': 'uint'}}],
                                  'primitiveArrayCount': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nGet the number of primitive arrays for this surface.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Number of primitive arrays ',
                                                                          'qualifiers': [],
                                                                          'type': 'int'},
                                                           'returnType': 'int',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                  'tangent': [{'argInfo': {'name': {'doc': 'the name of the uv set tangent data should be returned for',
                                                                    'type': 'MString'}},
                                               'args': [('name',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet a tangent set by name.',
                                               'inArgs': ['name'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The tangent data (which may be empty). ',
                                                              'qualifiers': [],
                                                              'type': 'MGeometryData'},
                                               'returnType': 'MGeometryData',
                                               'static': False,
                                               'typeQualifiers': {'name': ['const',
                                                                           '&']},
                                               'types': {'name': 'MString'}}],
                                  'texCoord': [{'argInfo': {'name': {'doc': 'the name of the set to return',
                                                                     'type': 'MString'}},
                                                'args': [('name',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet a texture coordinate set by name.',
                                                'inArgs': ['name'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The texture coordinate data (which may be empty). ',
                                                               'qualifiers': [],
                                                               'type': 'MGeometryData'},
                                                'returnType': 'MGeometryData',
                                                'static': False,
                                                'typeQualifiers': {'name': ['const',
                                                                            '&']},
                                                'types': {'name': 'MString'}}]},
                      'pymelEnums': {}},
  'MGeometryList': {'enums': {'MCullMode': {'valueDocs': {'CCW': 'Cull counter-clockwise faces when rendering this geometry.',
                                                          'CW': 'Cull clockwise faces when rendering this geometry.',
                                                          'kCullCCW': 'Cull counter-clockwise faces when rendering this geometry.',
                                                          'kCullCW': 'Cull clockwise faces when rendering this geometry.',
                                                          'kCullNone': 'No culling should be performed on this geometry.',
                                                          'none': 'No culling should be performed on this geometry.'},
                                            'values': "Enum('MCullMode', {'kCullNone': 0, 'kCullCW': 1, 'kCullCCW': 2})"}},
                    'methods': {'addLast': [{'argInfo': {'components': {'doc': 'The optional set of components (faces) to include in the geometry. A NULL value indicates the whole object should be added',
                                                                        'type': 'MObject'},
                                                         'path': {'doc': 'The DAG path for the shape to add ',
                                                                  'type': 'MDagPath'}},
                                             'args': [('path',
                                                       'MDagPath',
                                                       'in'),
                                                      ('components',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {'components': None},
                                             'deprecated': False,
                                             'doc': '\r\nAdd the geometry representing a shape to this geometry iterator. Note that you are only able to add geometry items to MGeometryLists you have created using the public constructor. Trying to add elements to an iterator passed to you from Maya (e.g. in a shader render call) will fail.',
                                             'inArgs': ['path',
                                                        'components'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'True if the element was added to the iterator, false otherwise. ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'components': ['const',
                                                                               '*'],
                                                                'path': ['const',
                                                                         '&']},
                                             'types': {'components': 'MObject',
                                                       'path': 'MDagPath'}},
                                            {'argInfo': {'geometry': {'doc': 'the geometry cache to add ',
                                                                      'type': 'MGeometryLegacy'},
                                                         'matrix': {'doc': 'the transformation to associate with this geometry',
                                                                    'type': 'MMatrix'}},
                                             'args': [('geometry',
                                                       'MGeometryLegacy',
                                                       'in'),
                                                      ('matrix',
                                                       'MMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nAdd arbitrary geometry to this geometry iterator. Note that you are only able to add geometry items to MGeometryLists you have created using the public constructor. Trying to add elements to an iterator passed to you from Maya (e.g. in a shader render call) will fail.',
                                             'inArgs': ['geometry',
                                                        'matrix'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'True if the element was added to the iterator, false otherwise. ',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'geometry': ['const',
                                                                             '&'],
                                                                'matrix': ['const',
                                                                           '&']},
                                             'types': {'geometry': 'MGeometryLegacy',
                                                       'matrix': 'MMatrix'}}],
                                'cullMode': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the rendering cull mode to use for current element in the iterator.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The cull mode for the current element. ',
                                                             'qualifiers': [],
                                                             'type': ('MGeometryList',
                                                                      'MCullMode')},
                                              'returnType': ('MGeometryList',
                                                             'MCullMode'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                'geometry': [{'argInfo': {'setupFlags': {'doc': 'the parts of the rendering pipeline your shader needs setup in order to render. This can be any combination of kMatrices, kFixedFunctionLighting, kCulling, or kAll. For efficiency, you can avoid the overhead of setting up parts of the rendering pipeline not used by your shader (e.g. fixed function lighting).',
                                                                         'type': 'int'}},
                                              'args': [('setupFlags',
                                                        'int',
                                                        'in')],
                                              'defaults': {'setupFlags': 'kAll'},
                                              'deprecated': False,
                                              'doc': '\r\nGet the geometry for the current element in the iterator.',
                                              'inArgs': ['setupFlags'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The geometry for the current element. ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MGeometryLegacy'},
                                              'returnType': 'MGeometryLegacy',
                                              'static': False,
                                              'typeQualifiers': {'setupFlags': []},
                                              'types': {'setupFlags': 'int'}}],
                                'isDone': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nTests to see if the iterator has reached the end of the elements it contains. Once this method returns true, you should not call any further methods on the iterator.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'True if the iterator has no further elements, false if there are more elements remaining. ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                'length': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nQuery the total number of elements available through this iterator.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                'next': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nAdvance to the next element in the iterator. This should only be called if the iterator indicates it has more elements through the  isDone()  method. \r\n  Reprocessed example  \n Examples: \n \n   \n hlslShader.cpp . \n \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'objectToWorldMatrix': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGet the object to world matrix for the current element in the iterator.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The matrix for the current element. ',
                                                                        'qualifiers': ['&'],
                                                                        'type': 'MMatrix'},
                                                         'returnType': 'MMatrix',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                'path': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGet the dag path for the current element in the iterator.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'MDagPath'},
                                          'returnType': 'MDagPath',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'projectionMatrix': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the camera project matrix for the current element in the iterator.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The matrix for the current element. ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MMatrix'},
                                                      'returnType': 'MMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                'reset': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReset this iterator to the first element. This allows you to iterate multiple times through the list. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                'setCurrentElement': [{'argInfo': {'i': {'doc': 'the index of the element you want to access ',
                                                                         'type': 'int'}},
                                                       'args': [('i',
                                                                 'int',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nRandomly access the ith element in the iterator.',
                                                       'inArgs': ['i'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'i': []},
                                                       'types': {'i': 'int'}}],
                                'viewMatrix': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the camera view matrix for the current element in the iterator.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The matrix for the current element. ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MMatrix'},
                                                'returnType': 'MMatrix',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                    'pymelEnums': {'MCullMode': "Enum('MCullMode', [('none', 0), ('kCullNone', 0), ('CW', 1), ('kCullCW', 1), ('CCW', 2), ('kCullCCW', 2)], multiKeys=True)"}},
  'MGeometryManager': {'enums': {'GeometricShape': {'valueDocs': {'cube': 'Cube with width, height and depth of 1, centered at 0,0,0.',
                                                                  'kDefaultCube': 'Cube with width, height and depth of 1, centered at 0,0,0.',
                                                                  'kDefaultPlane': 'Plane with width and height of 1, centered at 0,0,0. Assuming "Y-Up" orientation: width = x-axis, and height = y-axis.',
                                                                  'kDefaultSphere': 'Sphere with radius 1, centered at 0,0,0.',
                                                                  'plane': 'Plane with width and height of 1, centered at 0,0,0. Assuming "Y-Up" orientation: width = x-axis, and height = y-axis.',
                                                                  'sphere': 'Sphere with radius 1, centered at 0,0,0.'},
                                                    'values': "Enum('GeometricShape', {'kDefaultSphere': 0, 'kDefaultPlane': 1, 'kDefaultCube': 2})"}},
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'dereferenceDefaultGeometry': [{'argInfo': {'geomIterator': {'doc': 'The geometry iterator returned from referenceDefaultGeometry().',
                                                                                                'type': 'MGeometryList'}},
                                                                   'args': [('geomIterator',
                                                                             'MGeometryList',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nThis is the companion method to  referenceDefaultGeometry()  and must always be called immediately after usage of data supplied by the reference call.',
                                                                   'inArgs': ['geomIterator'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': True,
                                                                   'typeQualifiers': {'geomIterator': ['*']},
                                                                   'types': {'geomIterator': 'MGeometryList'}}],
                                   'getGeometry': [{'argInfo': {'components': {'doc': 'an optional component group, for accessing a sub-selection of faces (e.g. the faces assigned to a material)',
                                                                               'type': 'MObject'},
                                                                'requirements': {'doc': 'the surface data you want in the cache. Attempting to access cache data not included in the requirements will fail. ',
                                                                                 'type': 'MGeometryRequirementsLegacy'},
                                                                'shape': {'doc': 'the surface ',
                                                                          'type': 'MDagPath'}},
                                                    'args': [('shape',
                                                              'MDagPath',
                                                              'in'),
                                                             ('requirements',
                                                              'MGeometryRequirementsLegacy',
                                                              'in'),
                                                             ('components',
                                                              'MObject',
                                                              'in')],
                                                    'defaults': {'components': None},
                                                    'deprecated': False,
                                                    'doc': '\r\nAccess the Geometry cache for a shape.',
                                                    'inArgs': ['shape',
                                                               'requirements',
                                                               'components'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The cached geometry. ',
                                                                   'qualifiers': [],
                                                                   'type': 'MGeometryLegacy'},
                                                    'returnType': 'MGeometryLegacy',
                                                    'static': True,
                                                    'typeQualifiers': {'components': ['*'],
                                                                       'requirements': ['const',
                                                                                        '&'],
                                                                       'shape': ['const',
                                                                                 '&']},
                                                    'types': {'components': 'MObject',
                                                              'requirements': 'MGeometryRequirementsLegacy',
                                                              'shape': 'MDagPath'}}],
                                   'referenceDefaultGeometry': [{'argInfo': {'geomShape': {'doc': 'Desired geometry shape. ',
                                                                                           'type': ('MGeometryManager',
                                                                                                    'GeometricShape')},
                                                                             'requirements': {'doc': 'Geometry requirements (MGeometryRequirementsLegacy).',
                                                                                              'type': 'MGeometryRequirementsLegacy'}},
                                                                 'args': [('geomShape',
                                                                           ('MGeometryManager',
                                                                            'GeometricShape'),
                                                                           'in'),
                                                                          ('requirements',
                                                                           'MGeometryRequirementsLegacy',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nObtain a reference to geometry for some "default" shapes maintained by the manager such that the geometry returned will match a set of geometric requirements ( MGeometryRequirementsLegacy ). The actual form is a geometric iterator ( MGeometryList ), which can be used to iterate over the internal data kept (MGeometry).',
                                                                 'inArgs': ['geomShape',
                                                                            'requirements'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '  A pointer to a geometry iterator (MGeometryList), which contains a reference to the geometric data (MGeometry). The MGeometry information which tries to match the requirements passed in. ( e.g. position, normal, texture coordinates, tangents, and binormals etc). It can be assumed that all data is floating point such that:   Positions are 3 float (x,y,z) positions   Normals are 3 float (x,y,z) vectors.   Texture coordinates are 2 float (u,v) tuples.   Tangents are 3 float (x,y,z) vectors.   Binormals are 3 float (x,y,z) vectors.     ',
                                                                                'qualifiers': ['*'],
                                                                                'type': 'MGeometryList'},
                                                                 'returnType': 'MGeometryList',
                                                                 'static': True,
                                                                 'typeQualifiers': {'geomShape': ['const'],
                                                                                    'requirements': ['const',
                                                                                                     '&']},
                                                                 'types': {'geomShape': ('MGeometryManager',
                                                                                         'GeometricShape'),
                                                                           'requirements': 'MGeometryRequirementsLegacy'}}]},
                       'pymelEnums': {'GeometricShape': "Enum('GeometricShape', [('sphere', 0), ('kDefaultSphere', 0), ('plane', 1), ('kDefaultPlane', 1), ('cube', 2), ('kDefaultCube', 2)], multiKeys=True)"}},
  'MGeometryPrimitive': {'enums': {'DrawPrimitiveType': {'valueDocs': {'invalidIndexType': 'Default value is not valid.',
                                                                       'kInvalidIndexType': 'Default value is not valid.',
                                                                       'kLineLoop': 'Corresponds to GL_LINE_LOOP in OpenGL (non-filled, connected line segments).',
                                                                       'kLineStrip': 'Corresponds to GL_LINE_STRIP in OpenGL.',
                                                                       'kLines': 'Corresponds to GL_LINES in OpenGL (individual unconnected line segments).',
                                                                       'kMaxDrawPrimitiveTypeIndex': 'Number of primitive types.',
                                                                       'kPoints': 'Corresponds to GL_POINTS in OpenGL.',
                                                                       'kPolygon': 'Corresponds to GL_POLYGON in OpenGL.',
                                                                       'kQuadStrip': 'Corresponds to GL_QUAD_STRIP in OpenGL.',
                                                                       'kQuads': 'Corresponds to GL_QUADS in OpenGL.',
                                                                       'kTriangleFan': 'Corresponds to GL_TRIANGLE_FAN in OpenGL.',
                                                                       'kTriangleStrip': 'Corresponds to GL_TRIANGLE_STRIP in OpenGL.',
                                                                       'kTriangles': 'Corresponds to GL_TRIANGLES In OpenGL.',
                                                                       'lineLoop': 'Corresponds to GL_LINE_LOOP in OpenGL (non-filled, connected line segments).',
                                                                       'lineStrip': 'Corresponds to GL_LINE_STRIP in OpenGL.',
                                                                       'lines': 'Corresponds to GL_LINES in OpenGL (individual unconnected line segments).',
                                                                       'maxDrawPrimitiveTypeIndex': 'Number of primitive types.',
                                                                       'points': 'Corresponds to GL_POINTS in OpenGL.',
                                                                       'polygon': 'Corresponds to GL_POLYGON in OpenGL.',
                                                                       'quadStrip': 'Corresponds to GL_QUAD_STRIP in OpenGL.',
                                                                       'quads': 'Corresponds to GL_QUADS in OpenGL.',
                                                                       'triangleFan': 'Corresponds to GL_TRIANGLE_FAN in OpenGL.',
                                                                       'triangleStrip': 'Corresponds to GL_TRIANGLE_STRIP in OpenGL.',
                                                                       'triangles': 'Corresponds to GL_TRIANGLES In OpenGL.'},
                                                         'values': "Enum('DrawPrimitiveType', {'kInvalidIndexType': 0, 'kPoints': 1, 'kLines': 2, 'kLineStrip': 3, 'kLineLoop': 4, 'kTriangles': 5, 'kTriangleStrip': 6, 'kTriangleFan': 7, 'kQuads': 8, 'kQuadStrip': 9, 'kPolygon': 10, 'kMaxDrawPrimitiveTypeIndex': 11})"}},
                         'methods': {'data': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRetrieve a pointer to the internal data',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                     'dataType': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn element data type.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': ('MGeometryData',
                                                                           'ElementType')},
                                                   'returnType': ('MGeometryData',
                                                                  'ElementType'),
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                     'drawPrimitiveType': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nGet the data type for the data.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': ('MGeometryPrimitive',
                                                                                    'DrawPrimitiveType')},
                                                            'returnType': ('MGeometryPrimitive',
                                                                           'DrawPrimitiveType'),
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                     'elementCount': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturn element count.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Element count. 0 is returned on error. ',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                     'uniqueID': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the per session unique identifier',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                         'pymelEnums': {'DrawPrimitiveType': "Enum('DrawPrimitiveType', [('invalidIndexType', 0), ('kInvalidIndexType', 0), ('points', 1), ('kPoints', 1), ('lines', 2), ('kLines', 2), ('lineStrip', 3), ('kLineStrip', 3), ('lineLoop', 4), ('kLineLoop', 4), ('triangles', 5), ('kTriangles', 5), ('triangleStrip', 6), ('kTriangleStrip', 6), ('triangleFan', 7), ('kTriangleFan', 7), ('quads', 8), ('kQuads', 8), ('quadStrip', 9), ('kQuadStrip', 9), ('polygon', 10), ('kPolygon', 10), ('maxDrawPrimitiveTypeIndex', 11), ('kMaxDrawPrimitiveTypeIndex', 11)], multiKeys=True)"}},
  'MGeometryRequirementsLegacy': {'enums': {},
                                  'methods': {'addBinormal': [{'argInfo': {'dimension': {'doc': 'the size of the normal requirement. Valid values are 3 and 4. Default is 3. ',
                                                                                         'type': 'int'},
                                                                           'name': {'doc': 'the name of the uv set to add binormal data for ',
                                                                                    'type': 'MString'}},
                                                               'args': [('name',
                                                                         'MString',
                                                                         'in'),
                                                                        ('dimension',
                                                                         'int',
                                                                         'in')],
                                                               'defaults': {'dimension': 3},
                                                               'deprecated': False,
                                                               'doc': '\r\nAdd a binormal set to the list of required elements.',
                                                               'inArgs': ['name',
                                                                          'dimension'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'dimension': [],
                                                                                  'name': ['const',
                                                                                           '&']},
                                                               'types': {'dimension': 'int',
                                                                         'name': 'MString'}}],
                                              'addColor': [{'argInfo': {'name': {'doc': 'the name of the color set to add ',
                                                                                 'type': 'MString'}},
                                                            'args': [('name',
                                                                      'MString',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nAdd a color set to the list of required elements.',
                                                            'inArgs': ['name'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'name': ['const',
                                                                                        '&']},
                                                            'types': {'name': 'MString'}}],
                                              'addComponentId': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nAdd component id to the set of required elements. \r\n',
                                                                  'inArgs': [],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                                              'addFaceOffsets': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nAdd face offsets to the set of required elements.',
                                                                  'inArgs': [],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                                              'addNormal': [{'argInfo': {'dimension': {'doc': 'the size of the normal requirement. Valid values are 3 and 4. Default is 3. ',
                                                                                       'type': 'int'}},
                                                             'args': [('dimension',
                                                                       'int',
                                                                       'in')],
                                                             'defaults': {'dimension': 3},
                                                             'deprecated': False,
                                                             'doc': '\r\nAdd normal to the set of required elements.',
                                                             'inArgs': ['dimension'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'dimension': []},
                                                             'types': {'dimension': 'int'}}],
                                              'addPosition': [{'argInfo': {'dimension': {'doc': 'the size of the position requirement. Valid values are 3 and 4. Default is 3. ',
                                                                                         'type': 'int'}},
                                                               'args': [('dimension',
                                                                         'int',
                                                                         'in')],
                                                               'defaults': {'dimension': 3},
                                                               'deprecated': False,
                                                               'doc': '\r\nAdd position to the set of required elements.',
                                                               'inArgs': ['dimension'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'dimension': []},
                                                               'types': {'dimension': 'int'}}],
                                              'addTangent': [{'argInfo': {'dimension': {'doc': 'the size of the normal requirement. Valid values are 3 and 4. Default is 3. ',
                                                                                        'type': 'int'},
                                                                          'name': {'doc': 'the name of the uv set to add tangent data for ',
                                                                                   'type': 'MString'}},
                                                              'args': [('name',
                                                                        'MString',
                                                                        'in'),
                                                                       ('dimension',
                                                                        'int',
                                                                        'in')],
                                                              'defaults': {'dimension': 3},
                                                              'deprecated': False,
                                                              'doc': '\r\nAdd a tangent set to the list of required elements.',
                                                              'inArgs': ['name',
                                                                         'dimension'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'dimension': [],
                                                                                 'name': ['const',
                                                                                          '&']},
                                                              'types': {'dimension': 'int',
                                                                        'name': 'MString'}}],
                                              'addTexCoord': [{'argInfo': {'name': {'doc': 'the name of the uv set to add ',
                                                                                    'type': 'MString'}},
                                                               'args': [('name',
                                                                         'MString',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nAdd a texture coordinate set to the list of required elements.',
                                                               'inArgs': ['name'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'name': ['const',
                                                                                           '&']},
                                                               'types': {'name': 'MString'}}]},
                                  'pymelEnums': {}},
  'MGlobal': {'enums': {'ListAdjustment': {'valueDocs': {'XORWithList': 'Any of the items which are already on the list will be removed. Any which are not already on the list will be added to the end of the list.',
                                                         'addToHeadOfList': 'Add the items to the beginning of the list.',
                                                         'addToList': 'Add the items to the end of the list.',
                                                         'kAddToHeadOfList': 'Add the items to the beginning of the list.',
                                                         'kAddToList': 'Add the items to the end of the list.',
                                                         'kRemoveFromList': 'Remove the items from the list.',
                                                         'kReplaceList': 'Totally replace the list with the given items.',
                                                         'kXORWithList': 'Any of the items which are already on the list will be removed. Any which are not already on the list will be added to the end of the list.',
                                                         'removeFromList': 'Remove the items from the list.',
                                                         'replaceList': 'Totally replace the list with the given items.'},
                                           'values': "Enum('ListAdjustment', {'kReplaceList': 0, 'kXORWithList': 1, 'kAddToList': 2, 'kRemoveFromList': 3, 'kAddToHeadOfList': 4})"},
                        'MMayaState': {'valueDocs': {'baseUIMode': "Running with UI enabled but Maya's std UI scripts not run.",
                                                     'batch': 'Running without a UI.',
                                                     'interactive': 'Running with a UI.',
                                                     'kBaseUIMode': "Running with UI enabled but Maya's std UI scripts not run.",
                                                     'kBatch': 'Running without a UI.',
                                                     'kInteractive': 'Running with a UI.',
                                                     'kLibraryApp': 'Running as a standalone (',
                                                     'libraryApp': 'Running as a standalone ('},
                                       'values': "Enum('MMayaState', {'kInteractive': 0, 'kBatch': 1, 'kLibraryApp': 2, 'kBaseUIMode': 3})"},
                        'MSelectionMode': {'valueDocs': {'componentMode': 'Select components.',
                                                         'kSelectComponentMode': 'Select components.',
                                                         'kSelectLeafMode': 'Select DAG leaves.',
                                                         'kSelectObjectMode': 'Select objects.',
                                                         'kSelectRootMode': 'Select DAG roots.',
                                                         'kSelectTemplateMode': 'Select templated objects.',
                                                         'leafMode': 'Select DAG leaves.',
                                                         'objectMode': 'Select objects.',
                                                         'rootMode': 'Select DAG roots.',
                                                         'templateMode': 'Select templated objects.'},
                                           'values': "Enum('MSelectionMode', {'kSelectObjectMode': 0, 'kSelectComponentMode': 1, 'kSelectRootMode': 2, 'kSelectLeafMode': 3, 'kSelectTemplateMode': 4})"},
                        'SelectionMethod': {'valueDocs': {'kSurfaceSelectMethod': 'Select based on the surface of the objects.',
                                                          'kWireframeSelectMethod': 'Select based on the wireframe of the objects.',
                                                          'surfaceSelectMethod': 'Select based on the surface of the objects.',
                                                          'wireframeSelectMethod': 'Select based on the wireframe of the objects.'},
                                            'values': "Enum('SelectionMethod', {'kSurfaceSelectMethod': 0, 'kWireframeSelectMethod': 1})"}},
              'invertibles': [('setPreselectionHiliteList',
                               'getPreselectionHiliteList'),
                              ('setHiliteList', 'getHiliteList'),
                              ('setYAxisUp', 'isYAxisUp'),
                              ('setMiscSelectionMask', 'miscSelectionMask'),
                              ('setZAxisUp', 'isZAxisUp'),
                              ('setObjectSelectionMask',
                               'objectSelectionMask'),
                              ('setRichSelection', 'getRichSelection'),
                              ('setTrackSelectionOrderEnabled',
                               'trackSelectionOrderEnabled'),
                              ('setErrorLogPathName', 'errorLogPathName'),
                              ('setAnimSelectionMask', 'animSelectionMask'),
                              ('setActiveSelectionList',
                               'getActiveSelectionList'),
                              ('setComponentSelectionMask',
                               'componentSelectionMask'),
                              ('setSelectionMode', 'selectionMode'),
                              ('setDisableStow', 'disableStow')],
              'methods': {'addToModel': [{'argInfo': {'object': {'doc': 'object to be added ',
                                                                 'type': 'MObject'},
                                                      'parent': {'doc': 'parent dag node (optional)',
                                                                 'type': 'MObject'}},
                                          'args': [('object',
                                                    'MObject',
                                                    'in'),
                                                   ('parent',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {'parent': 'MObject::kNullObj'},
                                          'deprecated': False,
                                          'doc': '\r\nThis method is used to add new dag objects to the model. If no parent node is specified, then the node is added under the world. When a node is added under the world, then a transform node is automatically created as a parent. This assumes that the node being added is not already a transform node. This method is only valid for dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will be returned.',
                                          'inArgs': ['object', 'parent'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'object': ['&'],
                                                             'parent': ['&']},
                                          'types': {'object': 'MObject',
                                                    'parent': 'MObject'}}],
                          'addToModelAt': [{'argInfo': {'object': {'doc': 'the object to be added to the DAG ',
                                                                   'type': 'MObject'},
                                                        'point': {'doc': 'translation vector ',
                                                                  'type': 'MVector'},
                                                        'rotOrder': {'doc': 'the order of the rotation',
                                                                     'type': ('MTransformationMatrix',
                                                                              'RotationOrder')},
                                                        'rotation': {'doc': 'rotation amount ',
                                                                     'type': 'double__array3'},
                                                        'scale': {'doc': 'scale amount ',
                                                                  'type': 'double__array3'}},
                                            'args': [('object',
                                                      'MObject',
                                                      'in'),
                                                     ('point',
                                                      'MVector',
                                                      'in'),
                                                     ('scale',
                                                      'double__array3',
                                                      'in'),
                                                     ('rotation',
                                                      'double__array3',
                                                      'in'),
                                                     ('rotOrder',
                                                      ('MTransformationMatrix',
                                                       'RotationOrder'),
                                                      'in')],
                                            'defaults': {'rotOrder': ('MTransformationMatrix',
                                                                      'RotationOrder',
                                                                      'kXYZ'),
                                                         'rotation': None,
                                                         'scale': None},
                                            'deprecated': False,
                                            'doc': '\r\nAdds the specified dag object to the DAG and transform the object by the specified arguments. This method is only valid for dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will be returned.',
                                            'inArgs': ['object',
                                                       'point',
                                                       'scale',
                                                       'rotation',
                                                       'rotOrder'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'object': ['&'],
                                                               'point': ['const',
                                                                         '&'],
                                                               'rotOrder': [],
                                                               'rotation': ['const'],
                                                               'scale': ['const']},
                                            'types': {'object': 'MObject',
                                                      'point': 'MVector',
                                                      'rotOrder': ('MTransformationMatrix',
                                                                   'RotationOrder'),
                                                      'rotation': 'double__array3',
                                                      'scale': 'double__array3'}}],
                          'animSelectionMask': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the animation selection mask.',
                                                 'inArgs': [],
                                                 'inverse': ('setAnimSelectionMask',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The selection mask',
                                                                'qualifiers': [],
                                                                'type': 'MSelectionMask'},
                                                 'returnType': 'MSelectionMask',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                          'apiVersion': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns a number describing the version of the Maya API at runtime.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'clearSelectionList': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nRemoves all items from the active selection list.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                          'closeErrorLog': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis method closes the API error log file. If error logging is currently enabled this method disables it. The error log is time and date stamped before it is closed. After the log is closed the error log path name is reset to the default path name. If the error log file is already closed, then no action is taken.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                          'componentSelectionMask': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the component selection mask.',
                                                      'inArgs': [],
                                                      'inverse': ('setComponentSelectionMask',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The component selection mask',
                                                                     'qualifiers': [],
                                                                     'type': 'MSelectionMask'},
                                                      'returnType': 'MSelectionMask',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                          'currentToolContext': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the current tool context as an  MObject .',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                          'defaultErrorLogPathName': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nDetermines the default path name of the error log file. Returns an empty string on failure.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Default path name',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                          'deleteNode': [{'argInfo': {'object': {'doc': 'node to be deleted',
                                                                 'type': 'MObject'}},
                                          'args': [('object',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDelete the given dag node or dependency graph node.',
                                          'inArgs': ['object'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'object': ['&']},
                                          'types': {'object': 'MObject'}}],
                          'disableStow': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThis method is used to query if the disabling of Stowing (hiding) and Unstowing (showing) windows is active..',
                                           'inArgs': [],
                                           'inverse': ('setDisableStow',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                          'displayError': [{'argInfo': {'theError': {'doc': 'The error string to be displayed ',
                                                                     'type': 'MString'}},
                                            'args': [('theError',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method is used to display an error in the script editor.',
                                            'inArgs': ['theError'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'theError': ['const',
                                                                            '&']},
                                            'types': {'theError': 'MString'}}],
                          'displayInfo': [{'argInfo': {'theMessage': {'doc': 'The message string to be displayed ',
                                                                      'type': 'MString'}},
                                           'args': [('theMessage',
                                                     'MString',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThis method is used to display an informational message in the script editor.',
                                           'inArgs': ['theMessage'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'theMessage': ['const',
                                                                             '&']},
                                           'types': {'theMessage': 'MString'}}],
                          'displayWarning': [{'argInfo': {'theWarning': {'doc': 'The warning string to be displayed ',
                                                                         'type': 'MString'}},
                                              'args': [('theWarning',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method is used to display a warning in the script editor.',
                                              'inArgs': ['theWarning'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'theWarning': ['const',
                                                                                '&']},
                                              'types': {'theWarning': 'MString'}}],
                          'doErrorLogEntry': [{'argInfo': {'errorLogEntry': {'doc': 'Information to log to file',
                                                                             'type': 'MString'}},
                                               'args': [('errorLogEntry',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nLogs an entry in the currently open log file. It is not necessary for error logging to be enabled, but a log file must be open. A newline is appended to each log entry.',
                                               'inArgs': ['errorLogEntry'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'errorLogEntry': ['const',
                                                                                    '&']},
                                               'types': {'errorLogEntry': 'MString'}}],
                          'errorLogPathName': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nDetermines the path name of the current error log file. Returns the null string on failure.',
                                                'inArgs': [],
                                                'inverse': ('setErrorLogPathName',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Error log path name',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                          'errorLoggingIsOn': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis method determines whether or not API errors are being logged.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Boolean value: true Errors are being logged false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                          'executeCommand': [{'argInfo': {'command': {'doc': 'The MEL command string to execute. ',
                                                                      'type': 'MString'},
                                                          'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                             'type': 'bool'},
                                                          'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false',
                                                                          'type': 'bool'}},
                                              'args': [('command',
                                                        'MString',
                                                        'in'),
                                                       ('displayEnabled',
                                                        'bool',
                                                        'in'),
                                                       ('undoEnabled',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'displayEnabled': False,
                                                           'undoEnabled': False},
                                              'deprecated': False,
                                              'doc': '\r\nExecutes a MEL command with no access to result. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                              'inArgs': ['command',
                                                         'displayEnabled',
                                                         'undoEnabled'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'command': ['const',
                                                                             '&'],
                                                                 'displayEnabled': [],
                                                                 'undoEnabled': []},
                                              'types': {'command': 'MString',
                                                        'displayEnabled': 'bool',
                                                        'undoEnabled': 'bool'}},
                                             {'argInfo': {'command': {'doc': 'The MEL command string to execute ',
                                                                      'type': 'MString'},
                                                          'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                             'type': 'bool'},
                                                          'result': {'doc': 'The command result ',
                                                                     'type': 'MCommandResult'},
                                                          'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false',
                                                                          'type': 'bool'}},
                                              'args': [('command',
                                                        'MString',
                                                        'in'),
                                                       ('result',
                                                        'MCommandResult',
                                                        'out'),
                                                       ('displayEnabled',
                                                        'bool',
                                                        'in'),
                                                       ('undoEnabled',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'displayEnabled': False,
                                                           'undoEnabled': False},
                                              'deprecated': False,
                                              'doc': '\r\nExecutes a MEL command that returns an  MCommandResult  from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                              'inArgs': ['command',
                                                         'displayEnabled',
                                                         'undoEnabled'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'command': ['const',
                                                                             '&'],
                                                                 'displayEnabled': [],
                                                                 'result': ['&'],
                                                                 'undoEnabled': []},
                                              'types': {'command': 'MString',
                                                        'displayEnabled': 'bool',
                                                        'result': 'MCommandResult',
                                                        'undoEnabled': 'bool'}},
                                             {'argInfo': {'command': {'doc': 'The MEL command string to execute ',
                                                                      'type': 'MString'},
                                                          'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                             'type': 'bool'},
                                                          'result': {'doc': 'The integer result ',
                                                                     'type': 'int'},
                                                          'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false',
                                                                          'type': 'bool'}},
                                              'args': [('command',
                                                        'MString',
                                                        'in'),
                                                       ('result',
                                                        'int',
                                                        'out'),
                                                       ('displayEnabled',
                                                        'bool',
                                                        'in'),
                                                       ('undoEnabled',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'displayEnabled': False,
                                                           'undoEnabled': False},
                                              'deprecated': False,
                                              'doc': '\r\nExecutes a MEL command that returns an integer result from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                              'inArgs': ['command',
                                                         'displayEnabled',
                                                         'undoEnabled'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'command': ['const',
                                                                             '&'],
                                                                 'displayEnabled': [],
                                                                 'result': ['&'],
                                                                 'undoEnabled': []},
                                              'types': {'command': 'MString',
                                                        'displayEnabled': 'bool',
                                                        'result': 'int',
                                                        'undoEnabled': 'bool'}},
                                             {'argInfo': {'command': {'doc': 'The MEL command string to execute ',
                                                                      'type': 'MString'},
                                                          'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                             'type': 'bool'},
                                                          'result': {'doc': 'The MIntArray result ',
                                                                     'type': 'MIntArray'},
                                                          'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false',
                                                                          'type': 'bool'}},
                                              'args': [('command',
                                                        'MString',
                                                        'in'),
                                                       ('result',
                                                        'MIntArray',
                                                        'out'),
                                                       ('displayEnabled',
                                                        'bool',
                                                        'in'),
                                                       ('undoEnabled',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'displayEnabled': False,
                                                           'undoEnabled': False},
                                              'deprecated': False,
                                              'doc': '\r\nExecutes a MEL command that returns an integer array result from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                              'inArgs': ['command',
                                                         'displayEnabled',
                                                         'undoEnabled'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'command': ['const',
                                                                             '&'],
                                                                 'displayEnabled': [],
                                                                 'result': ['&'],
                                                                 'undoEnabled': []},
                                              'types': {'command': 'MString',
                                                        'displayEnabled': 'bool',
                                                        'result': 'MIntArray',
                                                        'undoEnabled': 'bool'}},
                                             {'argInfo': {'command': {'doc': 'The MEL command string to execute ',
                                                                      'type': 'MString'},
                                                          'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                             'type': 'bool'},
                                                          'result': {'doc': 'The double result ',
                                                                     'type': 'double'},
                                                          'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false',
                                                                          'type': 'bool'}},
                                              'args': [('command',
                                                        'MString',
                                                        'in'),
                                                       ('result',
                                                        'double',
                                                        'out'),
                                                       ('displayEnabled',
                                                        'bool',
                                                        'in'),
                                                       ('undoEnabled',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'displayEnabled': False,
                                                           'undoEnabled': False},
                                              'deprecated': False,
                                              'doc': '\r\nExecutes a MEL command that returns a double result from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                              'inArgs': ['command',
                                                         'displayEnabled',
                                                         'undoEnabled'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'command': ['const',
                                                                             '&'],
                                                                 'displayEnabled': [],
                                                                 'result': ['&'],
                                                                 'undoEnabled': []},
                                              'types': {'command': 'MString',
                                                        'displayEnabled': 'bool',
                                                        'result': 'double',
                                                        'undoEnabled': 'bool'}},
                                             {'argInfo': {'command': {'doc': 'The MEL command string to execute ',
                                                                      'type': 'MString'},
                                                          'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                             'type': 'bool'},
                                                          'result': {'doc': 'The MDoubleArray result ',
                                                                     'type': 'MDoubleArray'},
                                                          'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false',
                                                                          'type': 'bool'}},
                                              'args': [('command',
                                                        'MString',
                                                        'in'),
                                                       ('result',
                                                        'MDoubleArray',
                                                        'out'),
                                                       ('displayEnabled',
                                                        'bool',
                                                        'in'),
                                                       ('undoEnabled',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'displayEnabled': False,
                                                           'undoEnabled': False},
                                              'deprecated': False,
                                              'doc': '\r\nExecutes a MEL command that returns a double array result from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                              'inArgs': ['command',
                                                         'displayEnabled',
                                                         'undoEnabled'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'command': ['const',
                                                                             '&'],
                                                                 'displayEnabled': [],
                                                                 'result': ['&'],
                                                                 'undoEnabled': []},
                                              'types': {'command': 'MString',
                                                        'displayEnabled': 'bool',
                                                        'result': 'MDoubleArray',
                                                        'undoEnabled': 'bool'}},
                                             {'argInfo': {'command': {'doc': 'The MEL command string to execute ',
                                                                      'type': 'MString'},
                                                          'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                             'type': 'bool'},
                                                          'result': {'doc': 'The MStringArray result ',
                                                                     'type': 'MStringArray'},
                                                          'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false',
                                                                          'type': 'bool'}},
                                              'args': [('command',
                                                        'MString',
                                                        'in'),
                                                       ('result',
                                                        'MStringArray',
                                                        'out'),
                                                       ('displayEnabled',
                                                        'bool',
                                                        'in'),
                                                       ('undoEnabled',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'displayEnabled': False,
                                                           'undoEnabled': False},
                                              'deprecated': False,
                                              'doc': '\r\nExecutes a MEL command that returns a string array result from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                              'inArgs': ['command',
                                                         'displayEnabled',
                                                         'undoEnabled'],
                                              'outArgs': ['result'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'command': ['const',
                                                                             '&'],
                                                                 'displayEnabled': [],
                                                                 'result': ['&'],
                                                                 'undoEnabled': []},
                                              'types': {'command': 'MString',
                                                        'displayEnabled': 'bool',
                                                        'result': 'MStringArray',
                                                        'undoEnabled': 'bool'}}],
                          'executeCommandOnIdle': [{'argInfo': {'command': {'doc': 'The MEL command string to add to idle queue. ',
                                                                            'type': 'MString'},
                                                                'displayEnabled': {'doc': 'Flag to enable display of command in Script Editor - defaults to false',
                                                                                   'type': 'bool'}},
                                                    'args': [('command',
                                                              'MString',
                                                              'in'),
                                                             ('displayEnabled',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {'displayEnabled': False},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets a MEL command to execute on the next idle event. Since the command will likely not be executed until some time after control is returned to caller, there is no access to the command results.',
                                                    'inArgs': ['command',
                                                               'displayEnabled'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'command': ['const',
                                                                                   '&'],
                                                                       'displayEnabled': []},
                                                    'types': {'command': 'MString',
                                                              'displayEnabled': 'bool'}}],
                          'executeCommandStringResult': [{'argInfo': {'command': {'doc': 'The MEL command string to execute ',
                                                                                  'type': 'MString'},
                                                                      'displayEnabled': {'doc': 'Flag to enable display of command in journal window - defaults to false ',
                                                                                         'type': 'bool'},
                                                                      'undoEnabled': {'doc': 'Flag to enable addition of command to undo queue - defaults to false ',
                                                                                      'type': 'bool'}},
                                                          'args': [('command',
                                                                    'MString',
                                                                    'in'),
                                                                   ('displayEnabled',
                                                                    'bool',
                                                                    'in'),
                                                                   ('undoEnabled',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {'displayEnabled': False,
                                                                       'undoEnabled': False},
                                                          'deprecated': False,
                                                          'doc': '\r\nExecutes a MEL command that returns a string result from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.',
                                                          'inArgs': ['command',
                                                                     'displayEnabled',
                                                                     'undoEnabled'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'String value returned by command',
                                                                         'qualifiers': [],
                                                                         'type': 'MString'},
                                                          'returnType': 'MString',
                                                          'static': True,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'command': ['const',
                                                                                         '&'],
                                                                             'displayEnabled': [],
                                                                             'undoEnabled': []},
                                                          'types': {'command': 'MString',
                                                                    'displayEnabled': 'bool',
                                                                    'undoEnabled': 'bool'}}],
                          'getAbsolutePathToResources': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturn the absolute path of Maya\'s "Resources" fold on the system, including the "Resources" folder itself.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': 'MString'},
                                                          'returnType': 'MString',
                                                          'static': True,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                          'getActiveSelectionList': [{'argInfo': {'dest': {'doc': 'Storage for the selection list ',
                                                                           'type': 'MSelectionList'},
                                                                  'orderedSelectionIfAvailable': {'doc': 'If true, and tracking is enabled, will return the selected items in the order that they were selected.',
                                                                                                  'type': 'bool'}},
                                                      'args': [('dest',
                                                                'MSelectionList',
                                                                'out'),
                                                               ('orderedSelectionIfAvailable',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {'orderedSelectionIfAvailable': False},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns a copy of the active selection list, or optionally a copy of the ordered active selection list. This is the active selection list but with components as well as objects appearing in the order that they were selected.',
                                                      'inArgs': ['orderedSelectionIfAvailable'],
                                                      'inverse': ('setActiveSelectionList',
                                                                  False),
                                                      'outArgs': ['dest'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'dest': ['&'],
                                                                         'orderedSelectionIfAvailable': []},
                                                      'types': {'dest': 'MSelectionList',
                                                                'orderedSelectionIfAvailable': 'bool'}}],
                          'getAssociatedSets': [{'argInfo': {'list': {'doc': 'items to finds sets for ',
                                                                      'type': 'MSelectionList'},
                                                             'setArray': {'doc': 'storage for the array of sets',
                                                                          'type': 'MObjectArray'}},
                                                 'args': [('list',
                                                           'MSelectionList',
                                                           'in'),
                                                          ('setArray',
                                                           'MObjectArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis utility method finds all the sets that the items in the given selection list are members of.',
                                                 'inArgs': ['list'],
                                                 'outArgs': ['setArray'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {'list': ['const',
                                                                             '&'],
                                                                    'setArray': ['&']},
                                                 'types': {'list': 'MSelectionList',
                                                           'setArray': 'MObjectArray'}}],
                          'getFunctionSetList': [{'argInfo': {'array': {'doc': 'storage for the array of strings',
                                                                        'type': 'MStringArray'},
                                                              'forObject': {'doc': 'object to get list of function sets for ',
                                                                            'type': 'MObject'}},
                                                  'args': [('forObject',
                                                            'MObject',
                                                            'in'),
                                                           ('array',
                                                            'MStringArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGets a list of strings that represent the type of each function set that will accept this object. The strings match the values in MFn.h.',
                                                  'inArgs': ['forObject'],
                                                  'outArgs': ['array'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {'array': ['&'],
                                                                     'forObject': []},
                                                  'types': {'array': 'MStringArray',
                                                            'forObject': 'MObject'}}],
                          'getHiliteList': [{'argInfo': {'dest': {'doc': 'Storage for the hilite list',
                                                                  'type': 'MSelectionList'}},
                                             'args': [('dest',
                                                       'MSelectionList',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns a copy of the hilite list. The hilite list contains all DAG objects that are hilited for component selection mode. (e.g. when the user right clicks over a Mesh object and chooses the "vertex" option the Mesh line drawing changes color and the mesh is added to the hiliteList.)',
                                             'inArgs': [],
                                             'inverse': ('setHiliteList',
                                                         False),
                                             'outArgs': ['dest'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'dest': ['&']},
                                             'types': {'dest': 'MSelectionList'}}],
                          'getLiveList': [{'argInfo': {'dest': {'doc': 'Storage for the selection list',
                                                                'type': 'MSelectionList'}},
                                           'args': [('dest',
                                                     'MSelectionList',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns a copy of the live list. When a user performs a "Modify->Make Live" in the user interface the currently selected objects are added to the live list.',
                                           'inArgs': [],
                                           'outArgs': ['dest'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'dest': ['&']},
                                           'types': {'dest': 'MSelectionList'}}],
                          'getPreselectionHiliteList': [{'argInfo': {'list': {'doc': 'Storage for the preselection highlight list.',
                                                                              'type': 'MSelectionList'}},
                                                         'args': [('list',
                                                                   'MSelectionList',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGets the objects for which Maya is displaying a preselection highlight in the viewports.',
                                                         'inArgs': [],
                                                         'inverse': ('setPreselectionHiliteList',
                                                                     False),
                                                         'outArgs': ['list'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': True,
                                                         'typeQualifiers': {'list': ['&']},
                                                         'types': {'list': 'MSelectionList'}}],
                          'getRichSelection': [{'argInfo': {'defaultToActiveSelection': {'doc': 'If true, Maya will return the active selection when no rich selection exists.',
                                                                                         'type': 'bool'},
                                                            'richSelection': {'doc': 'Storage for the rich selection ',
                                                                              'type': 'MRichSelection'}},
                                                'args': [('richSelection',
                                                          'MRichSelection',
                                                          'out'),
                                                         ('defaultToActiveSelection',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'defaultToActiveSelection': True},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the current rich selection (usually the active selection with any soft selection and symmetry applied). Optionally if no rich selection exists, the current active selection can be returned instead (reducing the need for duplicated code).',
                                                'inArgs': ['defaultToActiveSelection'],
                                                'inverse': ('setRichSelection',
                                                            False),
                                                'outArgs': ['richSelection'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'defaultToActiveSelection': [],
                                                                   'richSelection': ['&']},
                                                'types': {'defaultToActiveSelection': 'bool',
                                                          'richSelection': 'MRichSelection'}}],
                          'getSelectionListByName': [{'argInfo': {'list': {'doc': 'Selection list into which the objects matching the name will be placed.',
                                                                           'type': 'MSelectionList'},
                                                                  'name': {'doc': 'Regular expression to match object name. ',
                                                                           'type': 'MString'}},
                                                      'args': [('name',
                                                                'MString',
                                                                'in'),
                                                               ('list',
                                                                'MSelectionList',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method fills a selection list with all of the objects that match a specified name. The name may use the same type of regular expressions the can be used in MEL commands. For example, the pattern "pCube*" will match all occurances of objects that begin their names with "pCube".',
                                                      'inArgs': ['name'],
                                                      'outArgs': ['list'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'list': ['&'],
                                                                         'name': ['const',
                                                                                  '&']},
                                                      'types': {'list': 'MSelectionList',
                                                                'name': 'MString'}}],
                          'isRedoing': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns true if Maya is currently in the middle of an redo.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'isSelected': [{'argInfo': {'object': {'doc': 'Dependency node object to test. ',
                                                                 'type': 'MObject'}},
                                          'args': [('object',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermines whether the given object is on the active selection list.',
                                          'inArgs': ['object'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Boolean value: true if the object is selected, false otherwise.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': True,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'object': ['&']},
                                          'types': {'object': 'MObject'}}],
                          'isUndoing': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns true if Maya is currently in the middle of an undo.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'isYAxisUp': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method returns true if, currently, the Y-axis is UP.',
                                         'inArgs': [],
                                         'inverse': ('setYAxisUp', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Boolean value: true the Y-axis is Up, false otherwise.',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': True,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'isZAxisUp': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method returns true if, currently, the Z-axis is UP.',
                                         'inArgs': [],
                                         'inverse': ('setZAxisUp', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Boolean value: true the Z-axis is Up, false otherwise.',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': True,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'mayaState': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns an enumerated type specifying the way in which Maya was invoked.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': " MGlobal::kInteractive Running with a UI  MGlobal::kBatch Running without a UI  MGlobal::kLibraryApp Running as a standalone (MLibrary) application.  MGlobal::kBaseUIMode Running with UI enabled but Maya's std UI scripts not run.  ",
                                                        'qualifiers': [],
                                                        'type': ('MGlobal',
                                                                 'MMayaState')},
                                         'returnType': ('MGlobal',
                                                        'MMayaState'),
                                         'static': True,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                          'mayaVersion': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns a string describing this version of Maya.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The version string ',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                          'miscSelectionMask': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the miscellaneous selection mask.',
                                                 'inArgs': [],
                                                 'inverse': ('setMiscSelectionMask',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The selection mask',
                                                                'qualifiers': [],
                                                                'type': 'MSelectionMask'},
                                                 'returnType': 'MSelectionMask',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                          'objectSelectionMask': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the object selection mask.',
                                                   'inArgs': [],
                                                   'inverse': ('setObjectSelectionMask',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The selection mask',
                                                                  'qualifiers': [],
                                                                  'type': 'MSelectionMask'},
                                                   'returnType': 'MSelectionMask',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                          'optionVarDoubleValue': [{'argInfo': {'exists': {'doc': 'true if variable exists, false otherwise',
                                                                           'type': 'bool'},
                                                                'name': {'doc': 'option variable name ',
                                                                         'type': 'MString'}},
                                                    'args': [('name',
                                                              'MString',
                                                              'in'),
                                                             ('exists',
                                                              'bool',
                                                              'out')],
                                                    'defaults': {'exists': None},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis method is used to get the option variable value of type double',
                                                    'inArgs': ['name'],
                                                    'outArgs': ['exists'],
                                                    'returnInfo': {'doc': 'Value of the variable as a double. ',
                                                                   'qualifiers': [],
                                                                   'type': 'double'},
                                                    'returnType': 'double',
                                                    'static': True,
                                                    'typeQualifiers': {'exists': ['*'],
                                                                       'name': ['const',
                                                                                '&']},
                                                    'types': {'exists': 'bool',
                                                              'name': 'MString'}}],
                          'optionVarExists': [{'argInfo': {'name': {'doc': 'option variable name',
                                                                    'type': 'MString'}},
                                               'args': [('name',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method is used to check if the option variable exists',
                                               'inArgs': ['name'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if option variable exists ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {'name': ['const',
                                                                           '&']},
                                               'types': {'name': 'MString'}}],
                          'optionVarIntValue': [{'argInfo': {'exists': {'doc': 'true if variable exists, false otherwise',
                                                                        'type': 'bool'},
                                                             'name': {'doc': 'option variable name ',
                                                                      'type': 'MString'}},
                                                 'args': [('name',
                                                           'MString',
                                                           'in'),
                                                          ('exists',
                                                           'bool',
                                                           'out')],
                                                 'defaults': {'exists': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method is used to get the option variable value of int type',
                                                 'inArgs': ['name'],
                                                 'outArgs': ['exists'],
                                                 'returnInfo': {'doc': 'Value of the variable as an integer. ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': True,
                                                 'typeQualifiers': {'exists': ['*'],
                                                                    'name': ['const',
                                                                             '&']},
                                                 'types': {'exists': 'bool',
                                                           'name': 'MString'}}],
                          'optionVarStringValue': [{'argInfo': {'exists': {'doc': 'true if variable exists, false otherwise',
                                                                           'type': 'bool'},
                                                                'name': {'doc': 'option variable name ',
                                                                         'type': 'MString'}},
                                                    'args': [('name',
                                                              'MString',
                                                              'in'),
                                                             ('exists',
                                                              'bool',
                                                              'out')],
                                                    'defaults': {'exists': None},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis method is used to get the option variable value of type string',
                                                    'inArgs': ['name'],
                                                    'outArgs': ['exists'],
                                                    'returnInfo': {'doc': 'Value of the variable as a string. ',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': True,
                                                    'typeQualifiers': {'exists': ['*'],
                                                                       'name': ['const',
                                                                                '&']},
                                                    'types': {'exists': 'bool',
                                                              'name': 'MString'}}],
                          'removeFromModel': [{'argInfo': {'object': {'doc': 'dag node to be removed from the scene',
                                                                      'type': 'MObject'}},
                                               'args': [('object',
                                                         'MObject',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRemoves the specified dag node from the scene. This method is only valid for dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will be returned.',
                                               'inArgs': ['object'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'object': ['&']},
                                               'types': {'object': 'MObject'}}],
                          'removeOptionVar': [{'argInfo': {'name': {'doc': 'option variable name ',
                                                                    'type': 'MString'}},
                                               'args': [('name',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method is used to remove the option variable',
                                               'inArgs': ['name'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'name': ['const',
                                                                           '&']},
                                               'types': {'name': 'MString'}}],
                          'resetToDefaultErrorLogPathName': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nCloses the current log file if it is open, and then resets the log path to the default path. Logging is disabled and the log file speicified by the default path is not opened. If logging is disabled, it remains disabled. Use  startErrorLogging()  to enable logging to the default log file. If the current path is the default path, no action is taken, but an invalid parameter error is returned.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': True,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                          'select': [{'argInfo': {'listAdjustment': {'doc': 'Determines how the active selection list is modified. kReplaceList - totally replace the active list with the given items. kXORWithList - if one of the given items is in the active list take it out, otherwise add it to the active list. kAddToList - add the items to the list kRemoveFromList - remove the items from the list kAddToHeadOfList - add the items to beginning of the list',
                                                                     'type': ('MGlobal',
                                                                              'ListAdjustment')},
                                                  'object': {'doc': 'Object to make selected. ',
                                                             'type': 'MObject'}},
                                      'args': [('object',
                                                'MObject',
                                                'in'),
                                               ('listAdjustment',
                                                ('MGlobal',
                                                 'ListAdjustment'),
                                                'in')],
                                      'defaults': {'listAdjustment': ('MGlobal',
                                                                      'ListAdjustment',
                                                                      'kAddToList')},
                                      'deprecated': False,
                                      'doc': '\r\nPut the given object on the active selection list.',
                                      'inArgs': ['object',
                                                 'listAdjustment'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': True,
                                      'typeQualifiers': {'listAdjustment': [],
                                                         'object': ['&']},
                                      'types': {'listAdjustment': ('MGlobal',
                                                                   'ListAdjustment'),
                                                'object': 'MObject'}},
                                     {'argInfo': {'component': {'doc': 'Components to select. ',
                                                                'type': 'MObject'},
                                                  'listAdjustment': {'doc': 'Determines how the active selection list is modified. kReplaceList - totally replace the active list with the given items. kXORWithList - if one of the given items is in the active list take it out, otherwise add it to the active list. kAddToList - add the items to the list kRemoveFromList - remove the items from the list kAddToHeadOfList - add the items to beginning of the list',
                                                                     'type': ('MGlobal',
                                                                              'ListAdjustment')},
                                                  'object': {'doc': 'Object to make selected. ',
                                                             'type': 'MDagPath'}},
                                      'args': [('object',
                                                'MDagPath',
                                                'in'),
                                               ('component',
                                                'MObject',
                                                'in'),
                                               ('listAdjustment',
                                                ('MGlobal',
                                                 'ListAdjustment'),
                                                'in')],
                                      'defaults': {'listAdjustment': ('MGlobal',
                                                                      'ListAdjustment',
                                                                      'kAddToList')},
                                      'deprecated': False,
                                      'doc': '\r\nPut the given object or components on the active selection list. If the component is null then the object in the dag path will be selected, otherwise the given component will be selected.',
                                      'inArgs': ['object',
                                                 'component',
                                                 'listAdjustment'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': True,
                                      'typeQualifiers': {'component': ['const',
                                                                       '&'],
                                                         'listAdjustment': [],
                                                         'object': ['const',
                                                                    '&']},
                                      'types': {'component': 'MObject',
                                                'listAdjustment': ('MGlobal',
                                                                   'ListAdjustment'),
                                                'object': 'MDagPath'}}],
                          'selectByName': [{'argInfo': {'listAdjustment': {'doc': 'Determines how the active selection list is modified. kReplaceList - totally replace the active list with the given items. kXORWithList - if one of the given items is in the active list take it out, otherwise add it to the active list. kAddToList - add the items to the list kRemoveFromList - remove the items from the list kAddToHeadOfList - add the items to beginning of the list',
                                                                           'type': ('MGlobal',
                                                                                    'ListAdjustment')},
                                                        'name': {'doc': 'Regular expression to match object name. ',
                                                                 'type': 'MString'}},
                                            'args': [('name',
                                                      'MString',
                                                      'in'),
                                                     ('listAdjustment',
                                                      ('MGlobal',
                                                       'ListAdjustment'),
                                                      'in')],
                                            'defaults': {'listAdjustment': ('MGlobal',
                                                                            'ListAdjustment',
                                                                            'kAddToList')},
                                            'deprecated': False,
                                            'doc': '\r\nPuts objects that match the give name on the active selection list.',
                                            'inArgs': ['name',
                                                       'listAdjustment'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'listAdjustment': [],
                                                               'name': ['const',
                                                                        '&']},
                                            'types': {'listAdjustment': ('MGlobal',
                                                                         'ListAdjustment'),
                                                      'name': 'MString'}}],
                          'selectCommand': [{'argInfo': {'listAdjustment': {'doc': 'Determines how the active selection list is modified. kReplaceList - totally replace the active list with the given items. kXORWithList - if one of the given items is in the active list take it out, otherwise add it to the active list. kAddToList - add the items to the list kRemoveFromList - remove the items from the list kAddToHeadOfList - add the items to beginning of the list',
                                                                            'type': ('MGlobal',
                                                                                     'ListAdjustment')},
                                                         'src': {'doc': 'The source list ',
                                                                 'type': 'MSelectionList'}},
                                             'args': [('src',
                                                       'MSelectionList',
                                                       'in'),
                                                      ('listAdjustment',
                                                       ('MGlobal',
                                                        'ListAdjustment'),
                                                       'in')],
                                             'defaults': {'listAdjustment': ('MGlobal',
                                                                             'ListAdjustment',
                                                                             'kReplaceList')},
                                             'deprecated': False,
                                             'doc': '\r\nSet the active selection list, by calling the built in Maya select command. This differs from setActiveSelectionList in that in this version Maya takes over the selection list you give it and will be responsible for maintaing the necessary information required for undo, redo, and journalling.',
                                             'inArgs': ['src',
                                                        'listAdjustment'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'listAdjustment': [],
                                                                'src': ['const',
                                                                        '&']},
                                             'types': {'listAdjustment': ('MGlobal',
                                                                          'ListAdjustment'),
                                                       'src': 'MSelectionList'}}],
                          'selectFromScreen': [{'argInfo': {'listAdjustment': {'doc': 'Determines how the active selection list is modified. kReplaceList - totally replace the active list with the given items. kXORWithList - if one of the given items is in the active list take it out, otherwise add it to the active list. kAddToList - add the items to the list kRemoveFromList - remove the items from the list kAddToHeadOfList - add the items to beginning of the list ',
                                                                               'type': ('MGlobal',
                                                                                        'ListAdjustment')},
                                                            'selectMethod': {'doc': 'Determines how the selection is done. kWireframeSelectMethod - selection point must hit the wireframe of an object for it to be selected. kSurfaceSelectMethod - selection point can hit anywhere on the surface of an object for it to be selected.',
                                                                             'type': ('MGlobal',
                                                                                      'SelectionMethod')},
                                                            'x_pos': {'doc': 'X position on screen to select at. ',
                                                                      'type': 'short'},
                                                            'y_pos': {'doc': 'Y position on screen to select at. ',
                                                                      'type': 'short'}},
                                                'args': [('x_pos',
                                                          'short',
                                                          'in'),
                                                         ('y_pos',
                                                          'short',
                                                          'in'),
                                                         ('listAdjustment',
                                                          ('MGlobal',
                                                           'ListAdjustment'),
                                                          'in'),
                                                         ('selectMethod',
                                                          ('MGlobal',
                                                           'SelectionMethod'),
                                                          'in')],
                                                'defaults': {'listAdjustment': ('MGlobal',
                                                                                'ListAdjustment',
                                                                                'kAddToList'),
                                                             'selectMethod': ('MGlobal',
                                                                              'SelectionMethod',
                                                                              'kWireframeSelectMethod')},
                                                'deprecated': False,
                                                'doc': '\r\nPerform click-pick type selection on the dag. If an object intersects the click point then it is selected according to listAdjustment.',
                                                'inArgs': ['x_pos',
                                                           'y_pos',
                                                           'listAdjustment',
                                                           'selectMethod'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'listAdjustment': [],
                                                                   'selectMethod': [],
                                                                   'x_pos': ['const',
                                                                             '&'],
                                                                   'y_pos': ['const',
                                                                             '&']},
                                                'types': {'listAdjustment': ('MGlobal',
                                                                             'ListAdjustment'),
                                                          'selectMethod': ('MGlobal',
                                                                           'SelectionMethod'),
                                                          'x_pos': 'short',
                                                          'y_pos': 'short'}},
                                               {'argInfo': {'end_x': {'doc': 'End x position of selection rectangle ',
                                                                      'type': 'short'},
                                                            'end_y': {'doc': 'End y position of selection rectangle ',
                                                                      'type': 'short'},
                                                            'listAdjustment': {'doc': 'Determines how the active selection list is modified. kReplaceList - totally replace the active list with the given items. kXORWithList - if one of the given items is in the active list take it out, otherwise add it to the active list. kAddToList - add the items to the list kRemoveFromList - remove the items from the list kAddToHeadOfList - add the items to beginning of the list ',
                                                                               'type': ('MGlobal',
                                                                                        'ListAdjustment')},
                                                            'selectMethod': {'doc': 'Determines how the selection is done. kWireframeSelectMethod - if part of the wireframe of an object falls inside the select rectangle then it will be selected. kSurfaceSelectMethod - if any part of of an object falls inside the select rectangle then it will be selected.',
                                                                             'type': ('MGlobal',
                                                                                      'SelectionMethod')},
                                                            'start_x': {'doc': 'Start x position of selection rectangle ',
                                                                        'type': 'short'},
                                                            'start_y': {'doc': 'Start y position of selection rectangle ',
                                                                        'type': 'short'}},
                                                'args': [('start_x',
                                                          'short',
                                                          'in'),
                                                         ('start_y',
                                                          'short',
                                                          'in'),
                                                         ('end_x',
                                                          'short',
                                                          'in'),
                                                         ('end_y',
                                                          'short',
                                                          'in'),
                                                         ('listAdjustment',
                                                          ('MGlobal',
                                                           'ListAdjustment'),
                                                          'in'),
                                                         ('selectMethod',
                                                          ('MGlobal',
                                                           'SelectionMethod'),
                                                          'in')],
                                                'defaults': {'listAdjustment': ('MGlobal',
                                                                                'ListAdjustment',
                                                                                'kAddToList'),
                                                             'selectMethod': ('MGlobal',
                                                                              'SelectionMethod',
                                                                              'kWireframeSelectMethod')},
                                                'deprecated': False,
                                                'doc': '\r\nPerform marquee type selection on the dag. If an object intersects the selection rectangle, it is selected according to listAdjustment.',
                                                'inArgs': ['start_x',
                                                           'start_y',
                                                           'end_x',
                                                           'end_y',
                                                           'listAdjustment',
                                                           'selectMethod'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'end_x': ['const',
                                                                             '&'],
                                                                   'end_y': ['const',
                                                                             '&'],
                                                                   'listAdjustment': [],
                                                                   'selectMethod': [],
                                                                   'start_x': ['const',
                                                                               '&'],
                                                                   'start_y': ['const',
                                                                               '&']},
                                                'types': {'end_x': 'short',
                                                          'end_y': 'short',
                                                          'listAdjustment': ('MGlobal',
                                                                             'ListAdjustment'),
                                                          'selectMethod': ('MGlobal',
                                                                           'SelectionMethod'),
                                                          'start_x': 'short',
                                                          'start_y': 'short'}}],
                          'selectionMethod': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDetermines the selection method that should be used in the currently active viewport. This is useful as input to the "selectFromScreen" functions.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The selection method.',
                                                              'qualifiers': [],
                                                              'type': ('MGlobal',
                                                                       'SelectionMethod')},
                                               'returnType': ('MGlobal',
                                                              'SelectionMethod'),
                                               'static': True,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                          'selectionMode': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nDetermines Maya's selection mode.",
                                             'inArgs': [],
                                             'inverse': ('setSelectionMode',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The selection mode.',
                                                            'qualifiers': [],
                                                            'type': ('MGlobal',
                                                                     'MSelectionMode')},
                                             'returnType': ('MGlobal',
                                                            'MSelectionMode'),
                                             'static': True,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                          'setActiveSelectionList': [{'argInfo': {'listAdjustment': {'doc': 'Determines how the active selection list is modified. kReplaceList - totally replace the active list with the given items. kXORWithList - if one of the given items is in the active list take it out, otherwise add it to the active list. kAddToList - add the items to the list kRemoveFromList - remove the items from the list kAddToHeadOfList - add the items to beginning of the list',
                                                                                     'type': ('MGlobal',
                                                                                              'ListAdjustment')},
                                                                  'src': {'doc': 'The source list ',
                                                                          'type': 'MSelectionList'}},
                                                      'args': [('src',
                                                                'MSelectionList',
                                                                'in'),
                                                               ('listAdjustment',
                                                                ('MGlobal',
                                                                 'ListAdjustment'),
                                                                'in')],
                                                      'defaults': {'listAdjustment': ('MGlobal',
                                                                                      'ListAdjustment',
                                                                                      'kReplaceList')},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the active selection list. The selection items on the given list will update the contents of the active selection list as indicated by the listAdjustment parameter.',
                                                      'inArgs': ['src',
                                                                 'listAdjustment'],
                                                      'inverse': ('getActiveSelectionList',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'listAdjustment': [],
                                                                         'src': ['const',
                                                                                 '&']},
                                                      'types': {'listAdjustment': ('MGlobal',
                                                                                   'ListAdjustment'),
                                                                'src': 'MSelectionList'}}],
                          'setAnimSelectionMask': [{'argInfo': {'mask': {'doc': 'The mask to be set',
                                                                         'type': 'MSelectionMask'}},
                                                    'args': [('mask',
                                                              'MSelectionMask',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the animation selection mask to the supplied value',
                                                    'inArgs': ['mask'],
                                                    'inverse': ('animSelectionMask',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'mask': ['const',
                                                                                '&']},
                                                    'types': {'mask': 'MSelectionMask'}}],
                          'setComponentSelectionMask': [{'argInfo': {'mask': {'doc': 'The mask to be set',
                                                                              'type': 'MSelectionMask'}},
                                                         'args': [('mask',
                                                                   'MSelectionMask',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSet the component selection mask to the supplied value',
                                                         'inArgs': ['mask'],
                                                         'inverse': ('componentSelectionMask',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': True,
                                                         'typeQualifiers': {'mask': ['const',
                                                                                     '&']},
                                                         'types': {'mask': 'MSelectionMask'}}],
                          'setDisableStow': [{'argInfo': {'state': {'doc': 'true or false ',
                                                                    'type': 'bool'}},
                                              'args': [('state',
                                                        'bool',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method is used to make the visiblity of all Maya windows unchangable. If set to true, it disables any attempts to change the visiblity of any window. In addition, all popup windows will be supressed.',
                                              'inArgs': ['state'],
                                              'inverse': ('disableStow',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'state': []},
                                              'types': {'state': 'bool'}}],
                          'setDisplayCVs': [{'argInfo': {'src': {'doc': 'The source list ',
                                                                 'type': 'MSelectionList'},
                                                         'state': {'doc': 'Whether items should be marked on/off for drawing',
                                                                   'type': 'bool'}},
                                             'args': [('src',
                                                       'MSelectionList',
                                                       'in'),
                                                      ('state',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nControls drawing of control points in the specified selection list.',
                                             'inArgs': ['src', 'state'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'src': ['&'],
                                                                'state': []},
                                             'types': {'src': 'MSelectionList',
                                                       'state': 'bool'}}],
                          'setErrorLogPathName': [{'argInfo': {'logPathName': {'doc': 'Path of the new error log file',
                                                                               'type': 'MString'}},
                                                   'args': [('logPathName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nCloses the current log file if it is open, and then sets the log path to the given path. If logging is enabled, it remains enabled, but on the log file speicified by the new path. If logging is disabled, it remains disabled. Use  startErrorLogging()  to enable logging to the new file. If the given path name is the same as the current path name, no action is taken, but an invalid parameter error is returned.',
                                                   'inArgs': ['logPathName'],
                                                   'inverse': ('errorLogPathName',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'logPathName': ['const',
                                                                                      '&']},
                                                   'types': {'logPathName': 'MString'}}],
                          'setHiliteList': [{'argInfo': {'list': {'doc': 'The new hilite list.',
                                                                  'type': 'MSelectionList'}},
                                             'args': [('list',
                                                       'MSelectionList',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the current hilite list. The current selection list is unchanged.',
                                             'inArgs': ['list'],
                                             'inverse': ('getHiliteList',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'list': ['&']},
                                             'types': {'list': 'MSelectionList'}}],
                          'setMiscSelectionMask': [{'argInfo': {'mask': {'doc': 'The mask to be set',
                                                                         'type': 'MSelectionMask'}},
                                                    'args': [('mask',
                                                              'MSelectionMask',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the miscellaneous selection mask to the supplied value',
                                                    'inArgs': ['mask'],
                                                    'inverse': ('miscSelectionMask',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'mask': ['const',
                                                                                '&']},
                                                    'types': {'mask': 'MSelectionMask'}}],
                          'setObjectSelectionMask': [{'argInfo': {'mask': {'doc': 'The mask to set to',
                                                                           'type': 'MSelectionMask'}},
                                                      'args': [('mask',
                                                                'MSelectionMask',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the object selection mask to the supplied value',
                                                      'inArgs': ['mask'],
                                                      'inverse': ('objectSelectionMask',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'mask': ['const',
                                                                                  '&']},
                                                      'types': {'mask': 'MSelectionMask'}}],
                          'setOptionVarValue': [{'argInfo': {'name': {'doc': 'option variable name ',
                                                                      'type': 'MString'},
                                                             'value': {'doc': 'option variable value to set',
                                                                       'type': 'int'}},
                                                 'args': [('name',
                                                           'MString',
                                                           'in'),
                                                          ('value',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method is used to set the option variable value of int type',
                                                 'inArgs': ['name',
                                                            'value'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'true ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {'name': ['const',
                                                                             '&'],
                                                                    'value': []},
                                                 'types': {'name': 'MString',
                                                           'value': 'int'}},
                                                {'argInfo': {'optionVarName': {'doc': 'option variable name ',
                                                                               'type': 'MString'},
                                                             'value': {'doc': 'option variable value to set',
                                                                       'type': 'double'}},
                                                 'args': [('optionVarName',
                                                           'MString',
                                                           'in'),
                                                          ('value',
                                                           'double',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method is used to set the option variable value of type double',
                                                 'inArgs': ['optionVarName',
                                                            'value'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'true ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {'optionVarName': ['const',
                                                                                      '&'],
                                                                    'value': []},
                                                 'types': {'optionVarName': 'MString',
                                                           'value': 'double'}},
                                                {'argInfo': {'name': {'doc': 'option variable name ',
                                                                      'type': 'MString'},
                                                             'value': {'doc': 'option variable value to set',
                                                                       'type': 'MString'}},
                                                 'args': [('name',
                                                           'MString',
                                                           'in'),
                                                          ('value',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method is used to set the option variable value of type string',
                                                 'inArgs': ['name',
                                                            'value'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'true ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {'name': ['const',
                                                                             '&'],
                                                                    'value': []},
                                                 'types': {'name': 'MString',
                                                           'value': 'MString'}}],
                          'setPreselectionHiliteList': [{'argInfo': {'list': {'doc': 'List of objects/components to highlight.',
                                                                              'type': 'MSelectionList'}},
                                                         'args': [('list',
                                                                   'MSelectionList',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the objects for which Maya will display a preselection highlight in the viewports.',
                                                         'inArgs': ['list'],
                                                         'inverse': ('getPreselectionHiliteList',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': True,
                                                         'typeQualifiers': {'list': ['const',
                                                                                     '&']},
                                                         'types': {'list': 'MSelectionList'}}],
                          'setRichSelection': [{'argInfo': {'src': {'doc': 'The source list',
                                                                    'type': 'MRichSelection'}},
                                                'args': [('src',
                                                          'MRichSelection',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet the current rich selection.',
                                                'inArgs': ['src'],
                                                'inverse': ('getRichSelection',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'src': ['const',
                                                                           '&']},
                                                'types': {'src': 'MRichSelection'}}],
                          'setSelectionMode': [{'argInfo': {'mode': {'doc': 'The mode to be set',
                                                                     'type': ('MGlobal',
                                                                              'MSelectionMode')}},
                                                'args': [('mode',
                                                          ('MGlobal',
                                                           'MSelectionMode'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the selection mode.',
                                                'inArgs': ['mode'],
                                                'inverse': ('selectionMode',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'mode': []},
                                                'types': {'mode': ('MGlobal',
                                                                   'MSelectionMode')}}],
                          'setTrackSelectionOrderEnabled': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable the tracking of selection order.',
                                                                                    'type': 'bool'}},
                                                             'args': [('enable',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSet whether Maya should maintain an active selection list which maintains object and component selection order.',
                                                             'inArgs': ['enable'],
                                                             'inverse': ('trackSelectionOrderEnabled',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'enable': []},
                                                             'types': {'enable': 'bool'}}],
                          'setYAxisUp': [{'argInfo': {'rotateView': {'doc': 'If true then the viewing camera will be rotated',
                                                                     'type': 'bool'}},
                                          'args': [('rotateView',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'rotateView': False},
                                          'deprecated': False,
                                          'doc': '\r\nThis method sets the flag to identify which axis is Up, and rotates the ground plane around around the X-axis 90 degrees to get the Y-Up from Z-Up.',
                                          'inArgs': ['rotateView'],
                                          'inverse': ('isYAxisUp', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'rotateView': []},
                                          'types': {'rotateView': 'bool'}}],
                          'setZAxisUp': [{'argInfo': {'rotateView': {'doc': 'If true then the viewing camera will be rotated',
                                                                     'type': 'bool'}},
                                          'args': [('rotateView',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'rotateView': False},
                                          'deprecated': False,
                                          'doc': '\r\nThis method sets the flag to identify which axis is Up, and rotates the ground plane around around the X-axis -90 degrees to get the Z-Up from Y-Up.',
                                          'inArgs': ['rotateView'],
                                          'inverse': ('isZAxisUp', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'rotateView': []},
                                          'types': {'rotateView': 'bool'}}],
                          'sourceFile': [{'argInfo': {'fileName': {'doc': 'The name of a file containing MEL commands',
                                                                   'type': 'MString'}},
                                          'args': [('fileName',
                                                    'MString',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nCauses the MEL command engine to open the named file and execute the contents of the file as a MEL script. If the provided fileName is a Unix absolute pathname, then that file is opened. If a relative pathname is provided, the directories indicated by the environment variable, MAYA_SCRIPT_PATH, will be searched for a matching filename.',
                                          'inArgs': ['fileName'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'fileName': ['const',
                                                                          '&']},
                                          'types': {'fileName': 'MString'}}],
                          'startErrorLogging': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method enables output to the API error log. If no log is currently open, a log file is opened at the current path. The error log is time and date stamped when it is opened. If output is already enabled, then no action is taken.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}},
                                                {'argInfo': {'logPathName': {'doc': 'Path of the error log file',
                                                                             'type': 'MString'}},
                                                 'args': [('logPathName',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method enables output to the API error log file specified by the path. If another error log file is already open this method time and date stamps the log, and closes it. The new error log is time and date stamped when it is opened.',
                                                 'inArgs': ['logPathName'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {'logPathName': ['const',
                                                                                    '&']},
                                                 'types': {'logPathName': 'MString'}}],
                          'stopErrorLogging': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis method disables output to the API error log but does not close the log file.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                          'trackSelectionOrderEnabled': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns whether the selection order is currerntly being tracked.',
                                                          'inArgs': [],
                                                          'inverse': ('setTrackSelectionOrderEnabled',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Boolean value: true if the selection order is being tracked, false otherwise.',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': True,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                          'unselect': [{'argInfo': {'object': {'doc': 'Object to unselect.',
                                                               'type': 'MObject'}},
                                        'args': [('object',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nRemove the given object from the active selection list.',
                                        'inArgs': ['object'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': True,
                                        'typeQualifiers': {'object': ['&']},
                                        'types': {'object': 'MObject'}},
                                       {'argInfo': {'component': {'doc': 'Components to be unselected.',
                                                                  'type': 'MObject'},
                                                    'object': {'doc': 'Object to unselect. ',
                                                               'type': 'MDagPath'}},
                                        'args': [('object',
                                                  'MDagPath',
                                                  'in'),
                                                 ('component',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nRemove the given object/components from the active selection list. If components is null then the object will be unselected, otherwise the components will be unselected.',
                                        'inArgs': ['object', 'component'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': True,
                                        'typeQualifiers': {'component': ['const',
                                                                         '&'],
                                                           'object': ['const',
                                                                      '&']},
                                        'types': {'component': 'MObject',
                                                  'object': 'MDagPath'}}],
                          'unselectByName': [{'argInfo': {'name': {'doc': 'Regular expression to match object name.',
                                                                   'type': 'MString'}},
                                              'args': [('name',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRemoves objects matching the pattern from the active selection list.',
                                              'inArgs': ['name'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'name': ['const',
                                                                          '&']},
                                              'types': {'name': 'MString'}}],
                          'upAxis': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nThis method returns the model's current up axis.",
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The models up axis',
                                                     'qualifiers': [],
                                                     'type': 'MVector'},
                                      'returnType': 'MVector',
                                      'static': True,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                          'viewFrame': [{'argInfo': {'time': {'doc': 'Time to set.',
                                                              'type': 'MTime'}},
                                         'args': [('time',
                                                   'MTime',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSets the global time to the specified time. This function is optimized for sequential time values that are monotonically increasing. While one can set the time randomly with this function, a significant performance hit will be incurred.',
                                         'inArgs': ['time'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': True,
                                         'typeQualifiers': {'time': ['const',
                                                                     '&']},
                                         'types': {'time': 'MTime'}},
                                        {'argInfo': {'time': {'doc': 'Time to set, in the units currently in effect for the user interface.',
                                                              'type': 'double'}},
                                         'args': [('time',
                                                   'double',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSets the global time to the specified time. This function is optimized for sequential time values that are monotonically increasing. While one can set the time randomly with this function, a significant performance hit will be incurred.',
                                         'inArgs': ['time'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': True,
                                         'typeQualifiers': {'time': []},
                                         'types': {'time': 'double'}}]},
              'pymelEnums': {'ListAdjustment': "Enum('ListAdjustment', [('replaceList', 0), ('kReplaceList', 0), ('XORWithList', 1), ('kXORWithList', 1), ('addToList', 2), ('kAddToList', 2), ('removeFromList', 3), ('kRemoveFromList', 3), ('addToHeadOfList', 4), ('kAddToHeadOfList', 4)], multiKeys=True)",
                             'MMayaState': "Enum('MMayaState', [('interactive', 0), ('kInteractive', 0), ('batch', 1), ('kBatch', 1), ('libraryApp', 2), ('kLibraryApp', 2), ('baseUIMode', 3), ('kBaseUIMode', 3)], multiKeys=True)",
                             'MSelectionMode': "Enum('MSelectionMode', [('objectMode', 0), ('kSelectObjectMode', 0), ('componentMode', 1), ('kSelectComponentMode', 1), ('rootMode', 2), ('kSelectRootMode', 2), ('leafMode', 3), ('kSelectLeafMode', 3), ('templateMode', 4), ('kSelectTemplateMode', 4)], multiKeys=True)",
                             'SelectionMethod': "Enum('SelectionMethod', [('surfaceSelectMethod', 0), ('kSurfaceSelectMethod', 0), ('wireframeSelectMethod', 1), ('kWireframeSelectMethod', 1)], multiKeys=True)"},
              'pymelMethods': {'animSelectionMask': 'getAnimSelectionMask',
                               'componentSelectionMask': 'getComponentSelectionMask',
                               'disableStow': 'getDisableStow',
                               'errorLogPathName': 'getErrorLogPathName',
                               'miscSelectionMask': 'getMiscSelectionMask',
                               'objectSelectionMask': 'getObjectSelectionMask',
                               'selectionMode': 'getSelectionMode',
                               'trackSelectionOrderEnabled': 'getTrackSelectionOrderEnabled'}},
  'MGraphEditorInfo': {'enums': {'AnimCurveQuery': {'valueDocs': {'allKnown': 'Curve(s) known to exist (independent of any Outliner filtering).',
                                                                  'highlighted': 'Curve(s) highlighted in Outliner (and visible in the viewport).',
                                                                  'kAnimCurveAllKnown': 'Curve(s) known to exist (independent of any Outliner filtering).',
                                                                  'kAnimCurveHighlighted': 'Curve(s) highlighted in Outliner (and visible in the viewport).',
                                                                  'kAnimCurveOutlinerOnly': 'Curve(s) present in Outliner (but not visible in the viewport).',
                                                                  'kAnimCurveSelected': 'Curve(s) selected (via keys/tangent handles) in the viewport.',
                                                                  'outlinerOnly': 'Curve(s) present in Outliner (but not visible in the viewport).',
                                                                  'selected': 'Curve(s) selected (via keys/tangent handles) in the viewport.'},
                                                    'values': "Enum('AnimCurveQuery', {'kAnimCurveOutlinerOnly': 0, 'kAnimCurveHighlighted': 1, 'kAnimCurveSelected': 2, 'kAnimCurveAllKnown': 3})"}},
                       'invertibles': [('setViewportBounds',
                                        'getViewportBounds')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'getAnimCurveNodes': [{'argInfo': {'animCurveNodeArray': {'doc': 'an array to store the found anim curves ',
                                                                                             'type': 'MObjectArray'},
                                                                      'animCurveQuery': {'doc': 'the anim curves to enumerate (by display state)',
                                                                                         'type': ('MGraphEditorInfo',
                                                                                                  'AnimCurveQuery')}},
                                                          'args': [('animCurveNodeArray',
                                                                    'MObjectArray',
                                                                    'out'),
                                                                   ('animCurveQuery',
                                                                    ('MGraphEditorInfo',
                                                                     'AnimCurveQuery'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\nReturns an array of animCurve nodes, based on the attached Graph Editor's state information, which captures:",
                                                          'inArgs': ['animCurveQuery'],
                                                          'outArgs': ['animCurveNodeArray'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'animCurveNodeArray': ['&'],
                                                                             'animCurveQuery': []},
                                                          'types': {'animCurveNodeArray': 'MObjectArray',
                                                                    'animCurveQuery': ('MGraphEditorInfo',
                                                                                       'AnimCurveQuery')}}],
                                   'getViewportBounds': [{'argInfo': {'bottom': {'doc': 'bottom co-ordinate ',
                                                                                 'type': 'double'},
                                                                      'left': {'doc': 'left co-ordinate ',
                                                                               'type': 'double'},
                                                                      'right': {'doc': 'right co-ordinate ',
                                                                                'type': 'double'},
                                                                      'top': {'doc': 'top co-ordinate',
                                                                              'type': 'double'}},
                                                          'args': [('left',
                                                                    'double',
                                                                    'out'),
                                                                   ('right',
                                                                    'double',
                                                                    'out'),
                                                                   ('bottom',
                                                                    'double',
                                                                    'out'),
                                                                   ('top',
                                                                    'double',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\nGet the attached Graph Editor's viewport bounds, using the currently defined animation time units.",
                                                          'inArgs': [],
                                                          'inverse': ('setViewportBounds',
                                                                      False),
                                                          'outArgs': ['left',
                                                                      'right',
                                                                      'bottom',
                                                                      'top'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'bottom': ['&'],
                                                                             'left': ['&'],
                                                                             'right': ['&'],
                                                                             'top': ['&']},
                                                          'types': {'bottom': 'double',
                                                                    'left': 'double',
                                                                    'right': 'double',
                                                                    'top': 'double'}},
                                                         {'argInfo': {'boundsArray': {'doc': 'an array of four doubles representing in order: (left, right, bottom, top) bounds co-ordinates',
                                                                                      'type': 'MDoubleArray'}},
                                                          'args': [('boundsArray',
                                                                    'MDoubleArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\nGet the attached Graph Editor's viewport bounds, using the currently defined animation time units.",
                                                          'inArgs': [],
                                                          'inverse': ('setViewportBounds',
                                                                      False),
                                                          'outArgs': ['boundsArray'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'boundsArray': ['&']},
                                                          'types': {'boundsArray': 'MDoubleArray'}}],
                                   'name': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of the currently attached Graph Editor (if any)',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                   'reset': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nResets all stored state information to be empty, thereby detaching from the currently attached Graph Editor (if any) \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                   'setViewportBounds': [{'argInfo': {'bottom': {'doc': 'bottom co-ordinate ',
                                                                                 'type': 'double'},
                                                                      'left': {'doc': 'left co-ordinate ',
                                                                               'type': 'double'},
                                                                      'right': {'doc': 'right co-ordinate ',
                                                                                'type': 'double'},
                                                                      'top': {'doc': 'top co-ordinate',
                                                                              'type': 'double'}},
                                                          'args': [('left',
                                                                    'double',
                                                                    'in'),
                                                                   ('right',
                                                                    'double',
                                                                    'in'),
                                                                   ('bottom',
                                                                    'double',
                                                                    'in'),
                                                                   ('top',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\nSet the attached Graph Editor's viewport bounds to those that are supplied using the currently defined animation time units as seen in the viewport.",
                                                          'inArgs': ['left',
                                                                     'right',
                                                                     'bottom',
                                                                     'top'],
                                                          'inverse': ('getViewportBounds',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'bottom': [],
                                                                             'left': [],
                                                                             'right': [],
                                                                             'top': []},
                                                          'types': {'bottom': 'double',
                                                                    'left': 'double',
                                                                    'right': 'double',
                                                                    'top': 'double'}},
                                                         {'argInfo': {'boundsArray': {'doc': 'an array of exactly four doubles representing in order: (left, right, bottom, top) bounds co-ordinates',
                                                                                      'type': 'MDoubleArray'}},
                                                          'args': [('boundsArray',
                                                                    'MDoubleArray',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\nSet the attached Graph Editor's viewport bounds to those that are supplied using the currently defined animation time units as seen in the viewport.",
                                                          'inArgs': ['boundsArray'],
                                                          'inverse': ('getViewportBounds',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'boundsArray': ['const',
                                                                                             '&']},
                                                          'types': {'boundsArray': 'MDoubleArray'}}]},
                       'pymelEnums': {'AnimCurveQuery': "Enum('AnimCurveQuery', [('outlinerOnly', 0), ('kAnimCurveOutlinerOnly', 0), ('highlighted', 1), ('kAnimCurveHighlighted', 1), ('selected', 2), ('kAnimCurveSelected', 2), ('allKnown', 3), ('kAnimCurveAllKnown', 3)], multiKeys=True)"}},
  'MHWShaderSwatchGenerator': {'enums': {},
                               'methods': {'createObj': [{'argInfo': {'obj': {'doc': 'The node object for which the swatch needs to be generated. ',
                                                                              'type': 'MObject'},
                                                                      'renderObj': {'doc': 'The node used to actually compute the swatch. In most situations, this can be the same as obj. This parameter can be used to request the computation of the swatch on another node, and display the swatch on the obj node. ',
                                                                                    'type': 'MObject'},
                                                                      'resolution': {'doc': 'The expected resolution of the swatch image. ',
                                                                                     'type': 'int'}},
                                                          'args': [('obj',
                                                                    'MObject',
                                                                    'in'),
                                                                   ('renderObj',
                                                                    'MObject',
                                                                    'in'),
                                                                   ('resolution',
                                                                    'int',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nClass constructor. Saves the Node object and image resolution as data members for future use.',
                                                          'inArgs': ['obj',
                                                                     'renderObj',
                                                                     'resolution'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': ['*'],
                                                                         'type': 'MSwatchRenderBase'},
                                                          'returnType': 'MSwatchRenderBase',
                                                          'static': True,
                                                          'typeQualifiers': {'obj': [],
                                                                             'renderObj': [],
                                                                             'resolution': []},
                                                          'types': {'obj': 'MObject',
                                                                    'renderObj': 'MObject',
                                                                    'resolution': 'int'}}],
                                           'doIteration': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nThis method will be called from the  MSwatchRenderRegister  for generating a swatch image.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                           'getSwatchBackgroundColor': [{'argInfo': {'a': {'doc': 'Storage variable for alpha component. ',
                                                                                           'type': 'float'},
                                                                                     'b': {'doc': 'Storage variable for blue component. ',
                                                                                           'type': 'float'},
                                                                                     'g': {'doc': 'Storage variable for green component. ',
                                                                                           'type': 'float'},
                                                                                     'r': {'doc': 'Storage variable for red component. ',
                                                                                           'type': 'float'}},
                                                                         'args': [('r',
                                                                                   'float',
                                                                                   'out'),
                                                                                  ('g',
                                                                                   'float',
                                                                                   'out'),
                                                                                  ('b',
                                                                                   'float',
                                                                                   'out'),
                                                                                  ('a',
                                                                                   'float',
                                                                                   'out')],
                                                                         'defaults': {},
                                                                         'deprecated': False,
                                                                         'doc': '\r\nThis method returns the default background color for the hardware rendered swatch.',
                                                                         'inArgs': [],
                                                                         'outArgs': ['r',
                                                                                     'g',
                                                                                     'b',
                                                                                     'a'],
                                                                         'returnInfo': {'doc': '',
                                                                                        'qualifiers': [],
                                                                                        'type': None},
                                                                         'returnType': None,
                                                                         'static': True,
                                                                         'typeQualifiers': {'a': ['&'],
                                                                                            'b': ['&'],
                                                                                            'g': ['&'],
                                                                                            'r': ['&']},
                                                                         'types': {'a': 'float',
                                                                                   'b': 'float',
                                                                                   'g': 'float',
                                                                                   'r': 'float'}}],
                                           'initialize': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method sets a swatch name, and registers a new swatch generator creation function for the swatch name. The string returned from this method can be used for node classification purpose. \r\n  Reprocessed example  \n Examples: \n \n   \n hwColorPerVertexShader.cpp ,  hwPhongShader.cpp , and  pluginMain.cpp . \n \n',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': ['&'],
                                                                          'type': 'MString'},
                                                           'returnType': 'MString',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}]},
                               'pymelEnums': {}},
  'MHairSystem': {'enums': {},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'getCollisionObject': [{'argInfo': {'hairSystem': {'doc': 'The hair system. ',
                                                                                 'type': 'MObject'},
                                                                  'index': {'doc': 'Which collision object to retrieve. The objectIndex parameter passed into your pre-frame callback or collision solver callback can be specified here. ',
                                                                            'type': 'int'}},
                                                      'args': [('hairSystem',
                                                                'MObject',
                                                                'in'),
                                                               ('index',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the requested collision object from the hair system.',
                                                      'inArgs': ['hairSystem',
                                                                 'index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The requested collision object, or the NULL object if not found. ',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'hairSystem': ['const'],
                                                                         'index': ['const']},
                                                      'types': {'hairSystem': 'MObject',
                                                                'index': 'int'}},
                                                     {'argInfo': {'hairSystem': {'doc': 'The hair system. ',
                                                                                 'type': 'MObject'},
                                                                  'logicalIndices': {'doc': 'Logical indices of each collision object returned.',
                                                                                     'type': 'MIntArray'},
                                                                  'objects': {'doc': 'Returns the collision objects in the same order that index-based getCollisionObject() returns them. ',
                                                                              'type': 'MObjectArray'}},
                                                      'args': [('hairSystem',
                                                                'MObject',
                                                                'in'),
                                                               ('objects',
                                                                'MObjectArray',
                                                                'out'),
                                                               ('logicalIndices',
                                                                'MIntArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns all collision objects for the hair system.',
                                                      'inArgs': ['hairSystem'],
                                                      'outArgs': ['objects',
                                                                  'logicalIndices'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'hairSystem': ['const'],
                                                                         'logicalIndices': ['&'],
                                                                         'objects': ['&']},
                                                      'types': {'hairSystem': 'MObject',
                                                                'logicalIndices': 'MIntArray',
                                                                'objects': 'MObjectArray'}}],
                              'getFollicle': [{'argInfo': {'hairSystem': {'doc': 'The hair system. ',
                                                                          'type': 'MObject'},
                                                           'index': {'doc': 'Which follicle to retrieve. The follicleIndex parameter passed into your collision solver callback can be specified here. ',
                                                                     'type': 'int'}},
                                               'args': [('hairSystem',
                                                         'MObject',
                                                         'in'),
                                                        ('index',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the requested follicle from the hair system.',
                                               'inArgs': ['hairSystem',
                                                          'index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The requested follicle, or the NULL object if not found. ',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': True,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'hairSystem': ['const'],
                                                                  'index': ['const']},
                                               'types': {'hairSystem': 'MObject',
                                                         'index': 'int'}},
                                              {'argInfo': {'follicles': {'doc': 'Returns the array of follicles in the same order that the index-based getFollicle() returns them. ',
                                                                         'type': 'MObjectArray'},
                                                           'hairSystem': {'doc': 'The hair system. ',
                                                                          'type': 'MObject'},
                                                           'logicalIndices': {'doc': 'Logical indices of each follicle returned.',
                                                                              'type': 'MIntArray'}},
                                               'args': [('hairSystem',
                                                         'MObject',
                                                         'in'),
                                                        ('follicles',
                                                         'MObjectArray',
                                                         'out'),
                                                        ('logicalIndices',
                                                         'MIntArray',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns all follicles for the hair system.',
                                               'inArgs': ['hairSystem'],
                                               'outArgs': ['follicles',
                                                           'logicalIndices'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'follicles': ['&'],
                                                                  'hairSystem': ['const'],
                                                                  'logicalIndices': ['&']},
                                               'types': {'follicles': 'MObjectArray',
                                                         'hairSystem': 'MObject',
                                                         'logicalIndices': 'MIntArray'}}],
                              'registerCollisionSolverCollide': [{'argInfo': {'fnPtr': {'doc': "Pointer to a function which implements the user's collision solver algorithm.",
                                                                                        'type': 'MHairSystemCollisionSolverCollideFnPtr'}},
                                                                  'args': [('fnPtr',
                                                                            'MHairSystemCollisionSolverCollideFnPtr',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': "\r\nRegister the user-supplied collision solver `fnPtr' with Maya. This method will be invoked per-hair times the number of iterations specified by the hairSystem node and the method can be used to perfrom several functions:",
                                                                  'inArgs': ['fnPtr'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': True,
                                                                  'typeQualifiers': {'fnPtr': []},
                                                                  'types': {'fnPtr': 'MHairSystemCollisionSolverCollideFnPtr'}}],
                              'registerCollisionSolverPreFrame': [{'argInfo': {'fnPtr': {'doc': "Pointer to a function which implements the user's pre-frame algorithm.",
                                                                                         'type': 'MHairSystemCollisionSolverPreFrameFnPtr'}},
                                                                   'args': [('fnPtr',
                                                                             'MHairSystemCollisionSolverPreFrameFnPtr',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': "\r\nRegister the user-supplied pre-frame method `fnPtr' with Maya. This method will be invoked at the start of each frame.",
                                                                   'inArgs': ['fnPtr'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': True,
                                                                   'typeQualifiers': {'fnPtr': []},
                                                                   'types': {'fnPtr': 'MHairSystemCollisionSolverPreFrameFnPtr'}}],
                              'registeringCallableScript': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturn true if this  MHairSystem  object has its callbacks defined in script. \r\n',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': 'bool'},
                                                             'returnType': 'bool',
                                                             'static': True,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                              'setRegisteringCallableScript': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nMark this  MHairSystem  object as one that will be passed callbacks defined in script. \r\n',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': True,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                              'unregisterCollisionSolverCollide': [{'argInfo': {},
                                                                    'args': [],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nDe-register any user-defined collision solver that might have been registered via  registerCollisionSolverCollide() . \r\n  Reprocessed example  \n Examples: \n \n   \n hairCollisionSolver.cpp . \n \n',
                                                                    'inArgs': [],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': True,
                                                                    'typeQualifiers': {},
                                                                    'types': {}}],
                              'unregisterCollisionSolverPreFrame': [{'argInfo': {},
                                                                     'args': [],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': '\r\nDe-register any user-defined pre-frame callback that might have been registered via  MHairSystem::registerCollisionSolverPreFrame . \r\n  Reprocessed example  \n Examples: \n \n   \n hairCollisionSolver.cpp . \n \n',
                                                                     'inArgs': [],
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': True,
                                                                     'typeQualifiers': {},
                                                                     'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'registeringCallableScript': 'getRegisteringCallableScript'}},
  'MHardwareRenderer': {'enums': {'BufferPixelFormat': {'valueDocs': {'RGBA_Fix8': '8 bit Red, Green, Blue, and Alpha channel',
                                                                      'RGBA_Float16': '16 bit Red, Green, Blue, and Alpha channel',
                                                                      'depth_Float32': '32 bit floating point depth buffer',
                                                                      'kDepth_Float32': '32 bit floating point depth buffer',
                                                                      'kRGBA_Fix8': '8 bit Red, Green, Blue, and Alpha channel',
                                                                      'kRGBA_Float16': '16 bit Red, Green, Blue, and Alpha channel'},
                                                        'values': "Enum('BufferPixelFormat', {'kRGBA_Fix8': 0, 'kRGBA_Float16': 1, 'kDepth_Float32': 2})"},
                                  'CallLocation': {'valueDocs': {'kPostExposure': 'After rendering one "exposure".',
                                                                 'kPostRendering': 'After rendering one frame. Before a possible fame buffer swap.',
                                                                 'kPreExposure': 'Before rendering one "exposure". If multiple exposures are are required to render one frame. After the frame buffer is cleared and model and view matrices are set up for the current exposure.',
                                                                 'kPreRendering': 'Before rendering one frame. No model or view matrices.',
                                                                 'postExposure': 'After rendering one "exposure".',
                                                                 'postRendering': 'After rendering one frame. Before a possible fame buffer swap.',
                                                                 'preExposure': 'Before rendering one "exposure". If multiple exposures are are required to render one frame. After the frame buffer is cleared and model and view matrices are set up for the current exposure.',
                                                                 'preRendering': 'Before rendering one frame. No model or view matrices.'},
                                                   'values': "Enum('CallLocation', {'kPreRendering': 0, 'kPreExposure': 1, 'kPostExposure': 2, 'kPostRendering': 3})"},
                                  'DrawProcedureStatusCode': {'valueDocs': {'failure': 'Failure.',
                                                                            'itemExists': 'Item already exists.',
                                                                            'itemNotFound': 'Item is not found.',
                                                                            'kFailure': 'Failure.',
                                                                            'kItemExists': 'Item already exists.',
                                                                            'kItemNotFound': 'Item is not found.',
                                                                            'kLocationNotFound': 'Location not found.',
                                                                            'kSuccess': 'Success.',
                                                                            'locationNotFound': 'Location not found.',
                                                                            'success': 'Success.'},
                                                              'values': "Enum('DrawProcedureStatusCode', {'kSuccess': 0, 'kFailure': 1, 'kItemExists': 2, 'kItemNotFound': 3, 'kLocationNotFound': 4})"},
                                  'GeometricShape': {'valueDocs': {'cube': 'Cube with width, height and depth of 1, centered at 0,0,0.',
                                                                   'kDefaultCube': 'Cube with width, height and depth of 1, centered at 0,0,0.',
                                                                   'kDefaultPlane': 'Plane with width and height of 1, centered at 0,0,0. Assuming "Y-Up" orientation: width = x-axis, and height = y-axis.',
                                                                   'kDefaultSphere': 'Sphere with radius 1, centered at 0,0,0.',
                                                                   'plane': 'Plane with width and height of 1, centered at 0,0,0. Assuming "Y-Up" orientation: width = x-axis, and height = y-axis.',
                                                                   'sphere': 'Sphere with radius 1, centered at 0,0,0.'},
                                                     'values': "Enum('GeometricShape', {'kDefaultSphere': 0, 'kDefaultPlane': 1, 'kDefaultCube': 2})"}},
                        'methods': {'addDrawProcedure': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                        'type': 'MString'},
                                                                      'drawProcedurePtr': {'doc': 'Pointer to a draw procedure ',
                                                                                           'type': 'MDrawProcedureBase'},
                                                                      'location': {'doc': 'Render location.',
                                                                                   'type': ('MHardwareRenderer',
                                                                                            'CallLocation')}},
                                                          'args': [('backEndString',
                                                                    'MString',
                                                                    'in'),
                                                                   ('drawProcedurePtr',
                                                                    'MDrawProcedureBase',
                                                                    'in'),
                                                                   ('location',
                                                                    ('MHardwareRenderer',
                                                                     'CallLocation'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': True,
                                                          'doc': '\n This method is obsolete. \n',
                                                          'inArgs': ['backEndString',
                                                                     'drawProcedurePtr',
                                                                     'location'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': ' DrawProcedureStatusCode : kSuccess, kFailure, kItemExists, or kLocationNotFound. if item already exists.   ',
                                                                         'qualifiers': [],
                                                                         'type': ('MHardwareRenderer',
                                                                                  'DrawProcedureStatusCode')},
                                                          'returnType': ('MHardwareRenderer',
                                                                         'DrawProcedureStatusCode'),
                                                          'static': False,
                                                          'typeQualifiers': {'backEndString': ['const',
                                                                                               '&'],
                                                                             'drawProcedurePtr': ['*'],
                                                                             'location': []},
                                                          'types': {'backEndString': 'MString',
                                                                    'drawProcedurePtr': 'MDrawProcedureBase',
                                                                    'location': ('MHardwareRenderer',
                                                                                 'CallLocation')}}],
                                    'backEndString': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': True,
                                                       'doc': '\n This method is obsolete. \n',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Pointer to a MHardwareRenderer. ',
                                                                      'qualifiers': ['&'],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                    'dereferenceGeometry': [{'argInfo': {'numberOfData': {'doc': 'Data count returned from referenceDefaultGeometry() ',
                                                                                          'type': 'uint'},
                                                                         'pGeomData': {'doc': 'The geometry data returned from referenceDefaultGeometry(). ',
                                                                                       'type': 'MGeometryData'}},
                                                             'args': [('pGeomData',
                                                                       'MGeometryData',
                                                                       'in'),
                                                                      ('numberOfData',
                                                                       'uint',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': True,
                                                             'doc': '\n This method is obsolete. \n',
                                                             'inArgs': ['pGeomData',
                                                                        'numberOfData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'numberOfData': ['unsigned'],
                                                                                'pGeomData': ['*']},
                                                             'types': {'numberOfData': 'uint',
                                                                       'pGeomData': 'MGeometryData'}}],
                                    'drawSwatchBackGroundQuads': [{'argInfo': {'numberOfRepeats': {'doc': 'Number of checkerboard repeats. Default is 8. ',
                                                                                                   'type': 'uint'},
                                                                               'quadColor': {'doc': 'The value for the quad color. Default is RGBA(0.5,0.5,0.5,1.0); ',
                                                                                             'type': 'MColor'},
                                                                               'textured': {'doc': 'Whether to draw with texture coordinates. Default is false. ',
                                                                                            'type': 'bool'}},
                                                                   'args': [('quadColor',
                                                                             'MColor',
                                                                             'in'),
                                                                            ('textured',
                                                                             'bool',
                                                                             'in'),
                                                                            ('numberOfRepeats',
                                                                             'uint',
                                                                             'in')],
                                                                   'defaults': {'numberOfRepeats': 8,
                                                                                'quadColor': 'MColor(0.5f,0.5f,0.5f,1.0f)',
                                                                                'textured': False},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nThis draws a set of quads in a checkboard pattern. Areas that are not drawn will have the background color show through.',
                                                                   'inArgs': ['quadColor',
                                                                              'textured',
                                                                              'numberOfRepeats'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'numberOfRepeats': ['unsigned'],
                                                                                      'quadColor': ['const',
                                                                                                    '&'],
                                                                                      'textured': []},
                                                                   'types': {'numberOfRepeats': 'uint',
                                                                             'quadColor': 'MColor',
                                                                             'textured': 'bool'}}],
                                    'findDrawProcedure': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                         'type': 'MString'},
                                                                       'location': {'doc': 'Render location. ',
                                                                                    'type': ('MHardwareRenderer',
                                                                                             'CallLocation')},
                                                                       'procName': {'doc': 'Name of a specific draw procedure to find.',
                                                                                    'type': 'MString'}},
                                                           'args': [('backEndString',
                                                                     'MString',
                                                                     'in'),
                                                                    ('location',
                                                                     ('MHardwareRenderer',
                                                                      'CallLocation'),
                                                                     'in'),
                                                                    ('procName',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': True,
                                                           'doc': '\n This method is obsolete. \n',
                                                           'inArgs': ['backEndString',
                                                                      'location',
                                                                      'procName'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Pointer to a MDrawProcedureBase. null is returned if not found. ',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'MDrawProcedureBase'},
                                                           'returnType': 'MDrawProcedureBase',
                                                           'static': False,
                                                           'typeQualifiers': {'backEndString': ['const',
                                                                                                '&'],
                                                                              'location': [],
                                                                              'procName': ['const',
                                                                                           '&']},
                                                           'types': {'backEndString': 'MString',
                                                                     'location': ('MHardwareRenderer',
                                                                                  'CallLocation'),
                                                                     'procName': 'MString'}}],
                                    'getBufferSize': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                     'type': 'MString'},
                                                                   'height': {'doc': 'The reference to the height value of the buffer. If the function fails for any reason, the value will not be modified.',
                                                                              'type': 'uint'},
                                                                   'width': {'doc': 'The reference to the width value of the buffer. If the function fails for any reason, the value will not be modified. ',
                                                                             'type': 'uint'}},
                                                       'args': [('backEndString',
                                                                 'MString',
                                                                 'in'),
                                                                ('width',
                                                                 'uint',
                                                                 'out'),
                                                                ('height',
                                                                 'uint',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': True,
                                                       'doc': '\n This method is obsolete. \n',
                                                       'inArgs': ['backEndString'],
                                                       'outArgs': ['width',
                                                                   'height'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'backEndString': ['const',
                                                                                            '&'],
                                                                          'height': ['unsigned',
                                                                                     '&'],
                                                                          'width': ['unsigned',
                                                                                    '&']},
                                                       'types': {'backEndString': 'MString',
                                                                 'height': 'uint',
                                                                 'width': 'uint'}}],
                                    'getColorBufferPixelFormat': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                                 'type': 'MString'},
                                                                               'fmt': {'doc': 'The reference to the pixel format value of the buffer. If the function fails for any reason, the value will not be modified.',
                                                                                       'type': ('MHardwareRenderer',
                                                                                                'BufferPixelFormat')}},
                                                                   'args': [('backEndString',
                                                                             'MString',
                                                                             'in'),
                                                                            ('fmt',
                                                                             ('MHardwareRenderer',
                                                                              'BufferPixelFormat'),
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': True,
                                                                   'doc': '\n This method is obsolete. \n',
                                                                   'inArgs': ['backEndString'],
                                                                   'outArgs': ['fmt'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'backEndString': ['const',
                                                                                                        '&'],
                                                                                      'fmt': ['&']},
                                                                   'types': {'backEndString': 'MString',
                                                                             'fmt': ('MHardwareRenderer',
                                                                                     'BufferPixelFormat')}}],
                                    'getCurrentExposureNumber': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                                'type': 'MString'},
                                                                              'number': {'doc': 'Current exposure number',
                                                                                         'type': 'uint'}},
                                                                  'args': [('backEndString',
                                                                            'MString',
                                                                            'in'),
                                                                           ('number',
                                                                            'uint',
                                                                            'out')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nThis method returns the current exposure number during rendering. If the renderer is not currently rendering a value of 0 is returned as the current exposure number.',
                                                                  'inArgs': ['backEndString'],
                                                                  'outArgs': ['number'],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'backEndString': ['const',
                                                                                                       '&'],
                                                                                     'number': ['unsigned',
                                                                                                '&']},
                                                                  'types': {'backEndString': 'MString',
                                                                            'number': 'uint'}}],
                                    'getDepthBufferPixelFormat': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                                 'type': 'MString'},
                                                                               'fmt': {'doc': 'The reference to the pixel format value of the buffer If the function fails for any reason, the value will not be modified.',
                                                                                       'type': ('MHardwareRenderer',
                                                                                                'BufferPixelFormat')}},
                                                                   'args': [('backEndString',
                                                                             'MString',
                                                                             'in'),
                                                                            ('fmt',
                                                                             ('MHardwareRenderer',
                                                                              'BufferPixelFormat'),
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': True,
                                                                   'doc': '\n This method is obsolete. \n',
                                                                   'inArgs': ['backEndString'],
                                                                   'outArgs': ['fmt'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'backEndString': ['const',
                                                                                                        '&'],
                                                                                      'fmt': ['&']},
                                                                   'types': {'backEndString': 'MString',
                                                                             'fmt': ('MHardwareRenderer',
                                                                                     'BufferPixelFormat')}}],
                                    'getDrawProcedureCount': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                             'type': 'MString'},
                                                                           'count': {'doc': 'Reference to the list count. This value is returned. If the function fails for any reason, then a value of 0 is returned.',
                                                                                     'type': 'uint'},
                                                                           'location': {'doc': 'Render location. ',
                                                                                        'type': ('MHardwareRenderer',
                                                                                                 'CallLocation')}},
                                                               'args': [('backEndString',
                                                                         'MString',
                                                                         'in'),
                                                                        ('location',
                                                                         ('MHardwareRenderer',
                                                                          'CallLocation'),
                                                                         'in'),
                                                                        ('count',
                                                                         'uint',
                                                                         'out')],
                                                               'defaults': {},
                                                               'deprecated': True,
                                                               'doc': '\n This method is obsolete. \n',
                                                               'inArgs': ['backEndString',
                                                                          'location'],
                                                               'outArgs': ['count'],
                                                               'returnInfo': {'doc': ' DrawProcedureStatusCode : kSuccess, kFailure, or kLocationNotFound. if item already exists.   ',
                                                                              'qualifiers': [],
                                                                              'type': ('MHardwareRenderer',
                                                                                       'DrawProcedureStatusCode')},
                                                               'returnType': ('MHardwareRenderer',
                                                                              'DrawProcedureStatusCode'),
                                                               'static': False,
                                                               'typeQualifiers': {'backEndString': ['const',
                                                                                                    '&'],
                                                                                  'count': ['unsigned',
                                                                                            '&'],
                                                                                  'location': []},
                                                               'types': {'backEndString': 'MString',
                                                                         'count': 'uint',
                                                                         'location': ('MHardwareRenderer',
                                                                                      'CallLocation')}}],
                                    'getDrawProcedureListNames': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                                 'type': 'MString'},
                                                                               'location': {'doc': 'Render location. ',
                                                                                            'type': ('MHardwareRenderer',
                                                                                                     'CallLocation')},
                                                                               'namesOfProcs': {'doc': 'Reference to a string array. This array will be modified to return the list of names. If the function fails for any reason, the array will not be modified.',
                                                                                                'type': 'MStringArray'}},
                                                                   'args': [('backEndString',
                                                                             'MString',
                                                                             'in'),
                                                                            ('location',
                                                                             ('MHardwareRenderer',
                                                                              'CallLocation'),
                                                                             'in'),
                                                                            ('namesOfProcs',
                                                                             'MStringArray',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': True,
                                                                   'doc': '\n This method is obsolete. \n',
                                                                   'inArgs': ['backEndString',
                                                                              'location',
                                                                              'namesOfProcs'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': ' DrawProcedureStatusCode : kSuccess, kFailure, or kLocationNotFound. if item already exists.   ',
                                                                                  'qualifiers': [],
                                                                                  'type': ('MHardwareRenderer',
                                                                                           'DrawProcedureStatusCode')},
                                                                   'returnType': ('MHardwareRenderer',
                                                                                  'DrawProcedureStatusCode'),
                                                                   'static': False,
                                                                   'typeQualifiers': {'backEndString': ['const',
                                                                                                        '&'],
                                                                                      'location': [],
                                                                                      'namesOfProcs': ['&']},
                                                                   'types': {'backEndString': 'MString',
                                                                             'location': ('MHardwareRenderer',
                                                                                          'CallLocation'),
                                                                             'namesOfProcs': 'MStringArray'}}],
                                    'getSwatchLightDirection': [{'argInfo': {'w': {'doc': 'The value for the w coord component ',
                                                                                   'type': 'float'},
                                                                             'x': {'doc': 'The value for the x coord component ',
                                                                                   'type': 'float'},
                                                                             'y': {'doc': 'The value for the y coord component ',
                                                                                   'type': 'float'},
                                                                             'z': {'doc': 'The value for the z coord component ',
                                                                                   'type': 'float'}},
                                                                 'args': [('x',
                                                                           'float',
                                                                           'out'),
                                                                          ('y',
                                                                           'float',
                                                                           'out'),
                                                                          ('z',
                                                                           'float',
                                                                           'out'),
                                                                          ('w',
                                                                           'float',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nThis method returns the direction vector of the default directional light used for rendering the swatch.',
                                                                 'inArgs': [],
                                                                 'outArgs': ['x',
                                                                             'y',
                                                                             'z',
                                                                             'w'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'w': ['&'],
                                                                                    'x': ['&'],
                                                                                    'y': ['&'],
                                                                                    'z': ['&']},
                                                                 'types': {'w': 'float',
                                                                           'x': 'float',
                                                                           'y': 'float',
                                                                           'z': 'float'}}],
                                    'getSwatchOrthoCameraSetting': [{'argInfo': {'b': {'doc': 'The bottom side clipping plane ',
                                                                                       'type': 'double'},
                                                                                 'f': {'doc': 'The far side clipping plane ',
                                                                                       'type': 'double'},
                                                                                 'l': {'doc': 'The left side clipping plane ',
                                                                                       'type': 'double'},
                                                                                 'n': {'doc': 'The near side clipping plane ',
                                                                                       'type': 'double'},
                                                                                 'r': {'doc': 'The right side clipping plane ',
                                                                                       'type': 'double'},
                                                                                 't': {'doc': 'The top side clipping plane ',
                                                                                       'type': 'double'}},
                                                                     'args': [('l',
                                                                               'double',
                                                                               'out'),
                                                                              ('r',
                                                                               'double',
                                                                               'out'),
                                                                              ('b',
                                                                               'double',
                                                                               'out'),
                                                                              ('t',
                                                                               'double',
                                                                               'out'),
                                                                              ('n',
                                                                               'double',
                                                                               'out'),
                                                                              ('f',
                                                                               'double',
                                                                               'out')],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': '\r\nThis method returns an orthographics camera clipping plane values which form the camera viewing volume. These values are the default values used for rendering the swatch.',
                                                                     'inArgs': [],
                                                                     'outArgs': ['l',
                                                                                 'r',
                                                                                 'b',
                                                                                 't',
                                                                                 'n',
                                                                                 'f'],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': False,
                                                                     'typeQualifiers': {'b': ['&'],
                                                                                        'f': ['&'],
                                                                                        'l': ['&'],
                                                                                        'n': ['&'],
                                                                                        'r': ['&'],
                                                                                        't': ['&']},
                                                                     'types': {'b': 'double',
                                                                               'f': 'double',
                                                                               'l': 'double',
                                                                               'n': 'double',
                                                                               'r': 'double',
                                                                               't': 'double'}}],
                                    'getSwatchPerspectiveCameraSetting': [{'argInfo': {'b': {'doc': 'The bottom side clipping plane ',
                                                                                             'type': 'double'},
                                                                                       'f': {'doc': 'The far side clipping plane ',
                                                                                             'type': 'double'},
                                                                                       'l': {'doc': 'The left side clipping plane ',
                                                                                             'type': 'double'},
                                                                                       'n': {'doc': 'The near side clipping plane ',
                                                                                             'type': 'double'},
                                                                                       'r': {'doc': 'The right side clipping plane ',
                                                                                             'type': 'double'},
                                                                                       't': {'doc': 'The top side clipping plane ',
                                                                                             'type': 'double'}},
                                                                           'args': [('l',
                                                                                     'double',
                                                                                     'out'),
                                                                                    ('r',
                                                                                     'double',
                                                                                     'out'),
                                                                                    ('b',
                                                                                     'double',
                                                                                     'out'),
                                                                                    ('t',
                                                                                     'double',
                                                                                     'out'),
                                                                                    ('n',
                                                                                     'double',
                                                                                     'out'),
                                                                                    ('f',
                                                                                     'double',
                                                                                     'out')],
                                                                           'defaults': {},
                                                                           'deprecated': False,
                                                                           'doc': '\r\nThis method returns a perspective camera clipping plane values which form the camera viewing volume. These values are the default values used for rendering the swatch.',
                                                                           'inArgs': [],
                                                                           'outArgs': ['l',
                                                                                       'r',
                                                                                       'b',
                                                                                       't',
                                                                                       'n',
                                                                                       'f'],
                                                                           'returnInfo': {'doc': '',
                                                                                          'qualifiers': [],
                                                                                          'type': None},
                                                                           'returnType': None,
                                                                           'static': False,
                                                                           'typeQualifiers': {'b': ['&'],
                                                                                              'f': ['&'],
                                                                                              'l': ['&'],
                                                                                              'n': ['&'],
                                                                                              'r': ['&'],
                                                                                              't': ['&']},
                                                                           'types': {'b': 'double',
                                                                                     'f': 'double',
                                                                                     'l': 'double',
                                                                                     'n': 'double',
                                                                                     'r': 'double',
                                                                                     't': 'double'}}],
                                    'getSwatchPerspectiveCameraTranslation': [{'argInfo': {'w': {'doc': 'The value for the w coord component ',
                                                                                                 'type': 'float'},
                                                                                           'x': {'doc': 'The value for the x coord component ',
                                                                                                 'type': 'float'},
                                                                                           'y': {'doc': 'The value for the y coord component ',
                                                                                                 'type': 'float'},
                                                                                           'z': {'doc': 'The value for the z coord component ',
                                                                                                 'type': 'float'}},
                                                                               'args': [('x',
                                                                                         'float',
                                                                                         'out'),
                                                                                        ('y',
                                                                                         'float',
                                                                                         'out'),
                                                                                        ('z',
                                                                                         'float',
                                                                                         'out'),
                                                                                        ('w',
                                                                                         'float',
                                                                                         'out')],
                                                                               'defaults': {},
                                                                               'deprecated': False,
                                                                               'doc': '\r\nThis method returns a perspective camera 3D translation values. These are the default values used for rendering the swatch.',
                                                                               'inArgs': [],
                                                                               'outArgs': ['x',
                                                                                           'y',
                                                                                           'z',
                                                                                           'w'],
                                                                               'returnInfo': {'doc': '',
                                                                                              'qualifiers': [],
                                                                                              'type': None},
                                                                               'returnType': None,
                                                                               'static': False,
                                                                               'typeQualifiers': {'w': ['&'],
                                                                                                  'x': ['&'],
                                                                                                  'y': ['&'],
                                                                                                  'z': ['&']},
                                                                               'types': {'w': 'float',
                                                                                         'x': 'float',
                                                                                         'y': 'float',
                                                                                         'z': 'float'}}],
                                    'getTotalExposureCount': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                             'type': 'MString'},
                                                                           'number': {'doc': 'Total exposure count.',
                                                                                      'type': 'uint'}},
                                                               'args': [('backEndString',
                                                                         'MString',
                                                                         'in'),
                                                                        ('number',
                                                                         'uint',
                                                                         'out')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nThis method returns the total number of exposures for rendering a single frame. If the renderer is not currently rendering a value of 0 is returned as the total exposure count.',
                                                               'inArgs': ['backEndString'],
                                                               'outArgs': ['number'],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'backEndString': ['const',
                                                                                                    '&'],
                                                                                  'number': ['unsigned',
                                                                                             '&']},
                                                               'types': {'backEndString': 'MString',
                                                                         'number': 'uint'}}],
                                    'glFunctionTable': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': True,
                                                         'doc': '\n This method is obsolete. \n',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Pointer to the function table class. This may be null, if the renderer could not be initialized properly. ',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'MGLFunctionTable'},
                                                         'returnType': 'MGLFunctionTable',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                    'insertDrawProcedure': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                           'type': 'MString'},
                                                                         'drawProcedurePtr': {'doc': 'Pointer to a draw procedure ',
                                                                                              'type': 'MDrawProcedureBase'},
                                                                         'listIndex': {'doc': 'Desired index position within the procedure list. ',
                                                                                       'type': 'uint'},
                                                                         'location': {'doc': 'Render location. ',
                                                                                      'type': ('MHardwareRenderer',
                                                                                               'CallLocation')},
                                                                         'moveExistingItem': {'doc': 'Move the procedure if it already exists in the list. The default value for this method argument is "false".',
                                                                                              'type': 'bool'}},
                                                             'args': [('backEndString',
                                                                       'MString',
                                                                       'in'),
                                                                      ('drawProcedurePtr',
                                                                       'MDrawProcedureBase',
                                                                       'in'),
                                                                      ('location',
                                                                       ('MHardwareRenderer',
                                                                        'CallLocation'),
                                                                       'in'),
                                                                      ('listIndex',
                                                                       'uint',
                                                                       'in'),
                                                                      ('moveExistingItem',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {'moveExistingItem': False},
                                                             'deprecated': True,
                                                             'doc': '\n This method is obsolete. \n',
                                                             'inArgs': ['backEndString',
                                                                        'drawProcedurePtr',
                                                                        'location',
                                                                        'listIndex',
                                                                        'moveExistingItem'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': ' DrawProcedureStatusCode : kSuccess, kFailure, kItemExists, or kLocationNotFound. if item already exists.   ',
                                                                            'qualifiers': [],
                                                                            'type': ('MHardwareRenderer',
                                                                                     'DrawProcedureStatusCode')},
                                                             'returnType': ('MHardwareRenderer',
                                                                            'DrawProcedureStatusCode'),
                                                             'static': False,
                                                             'typeQualifiers': {'backEndString': ['const',
                                                                                                  '&'],
                                                                                'drawProcedurePtr': ['*'],
                                                                                'listIndex': ['unsigned'],
                                                                                'location': [],
                                                                                'moveExistingItem': []},
                                                             'types': {'backEndString': 'MString',
                                                                       'drawProcedurePtr': 'MDrawProcedureBase',
                                                                       'listIndex': 'uint',
                                                                       'location': ('MHardwareRenderer',
                                                                                    'CallLocation'),
                                                                       'moveExistingItem': 'bool'}}],
                                    'makeResourceContextCurrent': [{'argInfo': {'backEndString': {'doc': 'Backend string.',
                                                                                                  'type': 'MString'}},
                                                                    'args': [('backEndString',
                                                                              'MString',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': True,
                                                                    'doc': '\n This method is obsolete. \n',
                                                                    'inArgs': ['backEndString'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'backEndString': ['const',
                                                                                                         '&']},
                                                                    'types': {'backEndString': 'MString'}}],
                                    'makeSwatchContextCurrent': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                                'type': 'MString'},
                                                                              'desiredHeight': {'doc': 'The desired height of the image to render. The dimensions of the context may differ. The size is clamped to be within the minimum and maximum context dimensions.',
                                                                                                'type': 'uint'},
                                                                              'desiredWidth': {'doc': 'The desired width of the image to render. The dimensions of the context may differ. The size is clamped to be within the minimum and maximum context dimensions. ',
                                                                                               'type': 'uint'}},
                                                                  'args': [('backEndString',
                                                                            'MString',
                                                                            'in'),
                                                                           ('desiredWidth',
                                                                            'uint',
                                                                            'in'),
                                                                           ('desiredHeight',
                                                                            'uint',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nThe swatch context is a "scratch" context which can be used to hardware render an image for swatch display. The swatch context has the following pixel format:',
                                                                  'inArgs': ['backEndString',
                                                                             'desiredWidth',
                                                                             'desiredHeight'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'backEndString': ['const',
                                                                                                       '&'],
                                                                                     'desiredHeight': ['unsigned',
                                                                                                       '&'],
                                                                                     'desiredWidth': ['unsigned',
                                                                                                      '&']},
                                                                  'types': {'backEndString': 'MString',
                                                                            'desiredHeight': 'uint',
                                                                            'desiredWidth': 'uint'}}],
                                    'readSwatchContextPixels': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                               'type': 'MString'},
                                                                             'image': {'doc': 'MImage with properly allocated block of pixels.',
                                                                                       'type': 'MImage'}},
                                                                 'args': [('backEndString',
                                                                           'MString',
                                                                           'in'),
                                                                          ('image',
                                                                           'MImage',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nRead the contents of the swatch context into an  MImage .  MImage  is assumed to be of the correct pixel format (24-bit RGBA, with 8-bits per channel).  MImage  is assumed to also have pre-allocated the correct amount of data as this routine will copy the swatch context contents directly into the  MImage .',
                                                                 'inArgs': ['backEndString'],
                                                                 'outArgs': ['image'],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'backEndString': ['const',
                                                                                                      '&'],
                                                                                    'image': ['&']},
                                                                 'types': {'backEndString': 'MString',
                                                                           'image': 'MImage'}}],
                                    'referenceDefaultGeometry': [{'argInfo': {'geomShape': {'doc': 'Desired geometry shape. ',
                                                                                            'type': ('MHardwareRenderer',
                                                                                                     'GeometricShape')},
                                                                              'indexLength': {'doc': 'Length of the indexing array.',
                                                                                              'type': 'uint'},
                                                                              'numberOfData': {'doc': 'Number of geometry data attributes returned. ',
                                                                                               'type': 'uint'},
                                                                              'pIndexing': {'doc': 'Reference to an indexing array used to access attribute data. This value is modified and returned if the routine is successful. Indexing can be assumed to be for representing triangles. That is each 3-tuple index can be used to access 1 triangle in the attribute data. ',
                                                                                            'type': 'uint'}},
                                                                  'args': [('geomShape',
                                                                            ('MHardwareRenderer',
                                                                             'GeometricShape'),
                                                                            'in'),
                                                                           ('numberOfData',
                                                                            'uint',
                                                                            'out'),
                                                                           ('pIndexing',
                                                                            'uint',
                                                                            'out'),
                                                                           ('indexLength',
                                                                            'uint',
                                                                            'out')],
                                                                  'defaults': {},
                                                                  'deprecated': True,
                                                                  'doc': '\n This method is obsolete. \n',
                                                                  'inArgs': ['geomShape'],
                                                                  'outArgs': ['numberOfData',
                                                                              'pIndexing',
                                                                              'indexLength'],
                                                                  'returnInfo': {'doc': 'A pointer to an array of geometric data attributes (MGeometryData). Currently four attributes are returned. In array order they are: position, normal, texture coordinates, tangents, and binormals. It can be assumed that all data is float such that:',
                                                                                 'qualifiers': ['*'],
                                                                                 'type': 'MGeometryData'},
                                                                  'returnType': 'MGeometryData',
                                                                  'static': False,
                                                                  'typeQualifiers': {'geomShape': [],
                                                                                     'indexLength': ['unsigned',
                                                                                                     '&'],
                                                                                     'numberOfData': ['unsigned',
                                                                                                      '&'],
                                                                                     'pIndexing': ['unsigned',
                                                                                                   '*&']},
                                                                  'types': {'geomShape': ('MHardwareRenderer',
                                                                                          'GeometricShape'),
                                                                            'indexLength': 'uint',
                                                                            'numberOfData': 'uint',
                                                                            'pIndexing': 'uint'}}],
                                    'removeDrawProcedure': [{'argInfo': {'backEndString': {'doc': 'Backend string. ',
                                                                                           'type': 'MString'},
                                                                         'drawProcedurePtr': {'doc': 'Pointer to a draw procedure. ',
                                                                                              'type': 'MDrawProcedureBase'},
                                                                         'location': {'doc': 'Render location.',
                                                                                      'type': ('MHardwareRenderer',
                                                                                               'CallLocation')}},
                                                             'args': [('backEndString',
                                                                       'MString',
                                                                       'in'),
                                                                      ('drawProcedurePtr',
                                                                       'MDrawProcedureBase',
                                                                       'in'),
                                                                      ('location',
                                                                       ('MHardwareRenderer',
                                                                        'CallLocation'),
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': True,
                                                             'doc': '\n This method is obsolete. \n',
                                                             'inArgs': ['backEndString',
                                                                        'drawProcedurePtr',
                                                                        'location'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': ' DrawProcedureStatusCode : kSuccess, kFailure, kItemNotFound, or kLocationNotFound. if item cannot be found.   ',
                                                                            'qualifiers': [],
                                                                            'type': ('MHardwareRenderer',
                                                                                     'DrawProcedureStatusCode')},
                                                             'returnType': ('MHardwareRenderer',
                                                                            'DrawProcedureStatusCode'),
                                                             'static': False,
                                                             'typeQualifiers': {'backEndString': ['const',
                                                                                                  '&'],
                                                                                'drawProcedurePtr': ['*'],
                                                                                'location': []},
                                                             'types': {'backEndString': 'MString',
                                                                       'drawProcedurePtr': 'MDrawProcedureBase',
                                                                       'location': ('MHardwareRenderer',
                                                                                    'CallLocation')}}],
                                    'restoreCurrent': [{'argInfo': {'backEndString': {'doc': 'Backend string.',
                                                                                      'type': 'MString'}},
                                                        'args': [('backEndString',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': True,
                                                        'doc': '\n This method is obsolete. \n',
                                                        'inArgs': ['backEndString'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'backEndString': ['const',
                                                                                             '&']},
                                                        'types': {'backEndString': 'MString'}}]},
                        'pymelEnums': {'BufferPixelFormat': "Enum('BufferPixelFormat', [('RGBA_Fix8', 0), ('kRGBA_Fix8', 0), ('RGBA_Float16', 1), ('kRGBA_Float16', 1), ('depth_Float32', 2), ('kDepth_Float32', 2)], multiKeys=True)",
                                       'CallLocation': "Enum('CallLocation', [('preRendering', 0), ('kPreRendering', 0), ('preExposure', 1), ('kPreExposure', 1), ('postExposure', 2), ('kPostExposure', 2), ('postRendering', 3), ('kPostRendering', 3)], multiKeys=True)",
                                       'DrawProcedureStatusCode': "Enum('DrawProcedureStatusCode', [('success', 0), ('kSuccess', 0), ('failure', 1), ('kFailure', 1), ('itemExists', 2), ('kItemExists', 2), ('itemNotFound', 3), ('kItemNotFound', 3), ('locationNotFound', 4), ('kLocationNotFound', 4)], multiKeys=True)",
                                       'GeometricShape': "Enum('GeometricShape', [('sphere', 0), ('kDefaultSphere', 0), ('plane', 1), ('kDefaultPlane', 1), ('cube', 2), ('kDefaultCube', 2)], multiKeys=True)"}},
  'MHwTextureManager': {'enums': {},
                        'methods': {'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'deregisterTextureFile': [{'argInfo': {'hTexture': {'doc': 'the texture handle to release',
                                                                                        'type': ('MHwTextureManager',
                                                                                                 'MHwTextureFileHandle')}},
                                                               'args': [('hTexture',
                                                                         ('MHwTextureManager',
                                                                          'MHwTextureFileHandle'),
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nDeregisters the given handle to a texture entry in the manager. If there are no other handles to this texture entry, the texture resource will be freed.',
                                                               'inArgs': ['hTexture'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': True,
                                                               'typeQualifiers': {'hTexture': ['const',
                                                                                               '&']},
                                                               'types': {'hTexture': ('MHwTextureManager',
                                                                                      'MHwTextureFileHandle')}}],
                                    'glBind': [{'argInfo': {'fileTextureObject': {'doc': 'the file texture node to bind ',
                                                                                  'type': 'MObject'},
                                                            'imageType': {'doc': 'the type of information you are expecting in the texture (e.g. color, normal, etc). If specified, this argument may be used to tune mipmap generation.',
                                                                          'type': ('MImageFileInfo',
                                                                                   'MImageType')},
                                                            'targetType': {'doc': 'the target type of the texture (e.g. 2D, cube map, etc). If the initial value of this argument is anything other than kHwTextureUnknown, this parameter acts as an input to specify the type you require, and the call will fail if the texture can not be bound to this type. If the initial value of this argument is kHwTextureUnknown, this parameter acts as a return value to let you know what type of texture has been bound. ',
                                                                           'type': ('MImageFileInfo',
                                                                                    'MHwTextureType')}},
                                                'args': [('fileTextureObject',
                                                          'MObject',
                                                          'in'),
                                                         ('targetType',
                                                          ('MImageFileInfo',
                                                           'MHwTextureType'),
                                                          'in'),
                                                         ('imageType',
                                                          ('MImageFileInfo',
                                                           'MImageType'),
                                                          'in')],
                                                'defaults': {'imageType': ('MImageFileInfo',
                                                                           'MImageType',
                                                                           'kImageTypeUnknown')},
                                                'deprecated': False,
                                                'doc': '\r\nBind the contents of a file texture node to the currently active OpenGL texture unit.',
                                                'inArgs': ['fileTextureObject',
                                                           'targetType',
                                                           'imageType'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'fileTextureObject': ['const',
                                                                                         '&'],
                                                                   'imageType': [],
                                                                   'targetType': ['&']},
                                                'types': {'fileTextureObject': 'MObject',
                                                          'imageType': ('MImageFileInfo',
                                                                        'MImageType'),
                                                          'targetType': ('MImageFileInfo',
                                                                         'MHwTextureType')}},
                                               {'argInfo': {'fileTextureConnection': {'doc': 'the file texture node to bind ',
                                                                                      'type': 'MPlug'},
                                                            'imageType': {'doc': 'the type of information you are expecting in the texture (e.g. color, normal, etc). If specified, this argument may be used to tune mipmap generation.',
                                                                          'type': ('MImageFileInfo',
                                                                                   'MImageType')},
                                                            'targetType': {'doc': 'the target type of the texture (e.g. 2D, cube map, etc). If the initial value of this argument is anything other than kHwTextureUnknown, this parameter acts as an input to specify the type you require, and the call will fail if the texture can not be bound to this type. If the initial value of this argument is kHwTextureUnknown, this parameter acts as a return value to let you know what type of texture has been bound. ',
                                                                           'type': ('MImageFileInfo',
                                                                                    'MHwTextureType')}},
                                                'args': [('fileTextureConnection',
                                                          'MPlug',
                                                          'in'),
                                                         ('targetType',
                                                          ('MImageFileInfo',
                                                           'MHwTextureType'),
                                                          'in'),
                                                         ('imageType',
                                                          ('MImageFileInfo',
                                                           'MImageType'),
                                                          'in')],
                                                'defaults': {'imageType': ('MImageFileInfo',
                                                                           'MImageType',
                                                                           'kImageTypeUnknown')},
                                                'deprecated': False,
                                                'doc': '\r\nBind the contents of a specific file texture node attribute (e.g. color, alpha) to the currently active OpenGL texture unit. As part of this operation, the texture target will also be enabled (i.e. there is no need to call glEnable( targetType) before or after calling this method).',
                                                'inArgs': ['fileTextureConnection',
                                                           'targetType',
                                                           'imageType'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'fileTextureConnection': ['const',
                                                                                             '&'],
                                                                   'imageType': [],
                                                                   'targetType': ['&']},
                                                'types': {'fileTextureConnection': 'MPlug',
                                                          'imageType': ('MImageFileInfo',
                                                                        'MImageType'),
                                                          'targetType': ('MImageFileInfo',
                                                                         'MHwTextureType')}},
                                               {'argInfo': {'hTexture': {'doc': 'the texture file handle to load ',
                                                                         'type': ('MHwTextureManager',
                                                                                  'MHwTextureFileHandle')},
                                                            'imageType': {'doc': 'the type of information you are expecting in the texture (e.g. color, normal, etc). If specified, this argument may be used to tune mipmap generation.',
                                                                          'type': ('MImageFileInfo',
                                                                                   'MImageType')},
                                                            'targetType': {'doc': 'the target type of the texture (e.g. 2D, cube map, etc). If the initial value of this argument is anything other than kHwTextureUnknown, this parameter acts as an input to specify the type you require, and the call will fail if the texture can not be bound to this type. If the initial value of this argument is kHwTextureUnknown, this parameter acts as a return value to let you know what type of texture has been bound. ',
                                                                           'type': ('MImageFileInfo',
                                                                                    'MHwTextureType')}},
                                                'args': [('hTexture',
                                                          ('MHwTextureManager',
                                                           'MHwTextureFileHandle'),
                                                          'in'),
                                                         ('targetType',
                                                          ('MImageFileInfo',
                                                           'MHwTextureType'),
                                                          'in'),
                                                         ('imageType',
                                                          ('MImageFileInfo',
                                                           'MImageType'),
                                                          'in')],
                                                'defaults': {'imageType': ('MImageFileInfo',
                                                                           'MImageType',
                                                                           'kImageTypeUnknown')},
                                                'deprecated': False,
                                                'doc': '\r\nBind the contents of a specific file to the currently active OpenGL texture unit. As part of this operation, the texture target will also be enabled (i.e. there is no need to call glEnable( targetType) before or after calling this method).',
                                                'inArgs': ['hTexture',
                                                           'targetType',
                                                           'imageType'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'hTexture': ['const',
                                                                                '&'],
                                                                   'imageType': [],
                                                                   'targetType': ['&']},
                                                'types': {'hTexture': ('MHwTextureManager',
                                                                       'MHwTextureFileHandle'),
                                                          'imageType': ('MImageFileInfo',
                                                                        'MImageType'),
                                                          'targetType': ('MImageFileInfo',
                                                                         'MHwTextureType')}}],
                                    'registerTextureFile': [{'argInfo': {'fileName': {'doc': 'the texture file to register ',
                                                                                      'type': 'MString'},
                                                                         'hTexture': {'doc': 'the output handle to a texture entry representing the given file.',
                                                                                      'type': ('MHwTextureManager',
                                                                                               'MHwTextureFileHandle')}},
                                                             'args': [('fileName',
                                                                       'MString',
                                                                       'in'),
                                                                      ('hTexture',
                                                                       ('MHwTextureManager',
                                                                        'MHwTextureFileHandle'),
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nRegister a named texture file. Returns a handle to a texture entry in the texture manager. The caller is responsible for calling the associated deregisterTextureFile to avoid leaking memory.',
                                                             'inArgs': ['fileName'],
                                                             'outArgs': ['hTexture'],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'fileName': ['const',
                                                                                             '&'],
                                                                                'hTexture': ['&']},
                                                             'types': {'fileName': 'MString',
                                                                       'hTexture': ('MHwTextureManager',
                                                                                    'MHwTextureFileHandle')}}],
                                    'textureFile': [{'argInfo': {'fileName': {'doc': 'the output file name',
                                                                              'type': 'MString'},
                                                                 'hTexture': {'doc': 'the texture handle to query ',
                                                                              'type': ('MHwTextureManager',
                                                                                       'MHwTextureFileHandle')}},
                                                     'args': [('hTexture',
                                                               ('MHwTextureManager',
                                                                'MHwTextureFileHandle'),
                                                               'in'),
                                                              ('fileName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturn the file name associated with a given texture file handle.',
                                                     'inArgs': ['hTexture',
                                                                'fileName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': True,
                                                     'typeQualifiers': {'fileName': ['&'],
                                                                        'hTexture': ['const',
                                                                                     '&']},
                                                     'types': {'fileName': 'MString',
                                                               'hTexture': ('MHwTextureManager',
                                                                            'MHwTextureFileHandle')}}]},
                        'pymelEnums': {}},
  'MHwrCallback': {'enums': {},
                   'methods': {'addCallback': [{'argInfo': {'callback': {'doc': 'object to add to the list of callbacks to invoke ',
                                                                         'type': 'MHwrCallback'},
                                                            'priority': {'doc': 'priority for this callback, lower priorities are invoked first ',
                                                                         'type': 'int'}},
                                                'args': [('callback',
                                                          'MHwrCallback',
                                                          'in'),
                                                         ('priority',
                                                          'int',
                                                          'in')],
                                                'defaults': {'priority': 0},
                                                'deprecated': False,
                                                'doc': '\r\nStatic procedure to add a rendering callback. The callbacks are stored internally in a sorted list and are invoked following the appropriate device state change depending on which methods are overridden. Adding the same callback more than once will have no effect.',
                                                'inArgs': ['callback',
                                                           'priority'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'callback': ['*'],
                                                                   'priority': []},
                                                'types': {'callback': 'MHwrCallback',
                                                          'priority': 'int'}}],
                               'deviceDeleted': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nMethod to override for being notified of device Deletion. \r\n  Reprocessed example  \n Examples: \n \n   \n hlslShader.cpp , and  hlslShader.h . \n \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'deviceLost': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nMethod to override for being notified of device Lost. \r\n  Reprocessed example  \n Examples: \n \n   \n hlslShader.cpp , and  hlslShader.h . \n \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'deviceNew': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nMethod to override for being notified of new device creation \r\n  Reprocessed example  \n Examples: \n \n   \n hlslShader.cpp , and  hlslShader.h . \n \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'deviceReset': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nMethod to override for being notified of device Reset. \r\n  Reprocessed example  \n Examples: \n \n   \n hlslShader.h . \n \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                               'removeCallback': [{'argInfo': {'callback': {'doc': 'object to remove from the list of callbacks ',
                                                                            'type': 'MHwrCallback'}},
                                                   'args': [('callback',
                                                             'MHwrCallback',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nStatic procedure to remove a rendering callback. The callback will be removed from the list of callbacks, but its up to the client to actually delete the object. Unstability may result if a callback is deleted and not removed from the callback list.Removing an un-installed callback will have no effect.',
                                                   'inArgs': ['callback'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'callback': ['*']},
                                                   'types': {'callback': 'MHwrCallback'}}]},
                   'pymelEnums': {}},
  'MIffFile': {'enums': {},
               'methods': {'beginGet': [{'argInfo': {'byteCount': {'doc': 'number of bytes in the chunk',
                                                                   'type': 'uint'},
                                                     'chunkTag': {'doc': 'tag of current chunk ',
                                                                  'type': 'MIffTag'}},
                                         'args': [('chunkTag',
                                                   'MIffTag',
                                                   'out'),
                                                  ('byteCount',
                                                   'uint',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nBegin grabbing the data.',
                                         'inArgs': [],
                                         'outArgs': ['chunkTag',
                                                     'byteCount'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'byteCount': ['unsigned',
                                                                          '*'],
                                                            'chunkTag': ['&']},
                                         'types': {'byteCount': 'uint',
                                                   'chunkTag': 'MIffTag'}}],
                           'beginReadGroup': [{'argInfo': {'id': {'doc': 'id of the group being read ',
                                                                  'type': 'MIffTag'},
                                                           'type': {'doc': 'type of the group being read',
                                                                    'type': 'MIffTag'}},
                                               'args': [('id',
                                                         'MIffTag',
                                                         'out'),
                                                        ('type',
                                                         'MIffTag',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nOpens a group for reading. A group is composed of several chunks (sub-groups). Provides the id and type of the current group. Can be followed by several calls to chunk reading functions or to nested beginReadGroup(...) calls if needed (depending on the file structure). The function endReadGroup(...) is used to closed a group skipping remaining data (including nested groups).',
                                               'inArgs': [],
                                               'outArgs': ['id', 'type'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'id': ['&'],
                                                                  'type': ['&']},
                                               'types': {'id': 'MIffTag',
                                                         'type': 'MIffTag'}}],
                           'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'close': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nClose the currently open file.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                           'endGet': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nFinish grabbing the data.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                           'endReadGroup': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nCloses group currently being read, skipping remaining data (including nested groups).',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                           'get': [{'argInfo': {'buf': {'doc': 'pointer to buffer in which to store the data read from the file. ',
                                                        'type': 'void'},
                                                'byteCount': {'doc': 'maximum number of bytes that buf can hold ',
                                                              'type': 'uint'}},
                                    'args': [('buf', 'void', 'out'),
                                             ('byteCount', 'uint', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': "\r\nAttempt to read 'byteCount' bytes from the file into the buffer pointed to by buf.",
                                    'inArgs': ['byteCount'],
                                    'outArgs': ['buf'],
                                    'returnInfo': {'doc': 'Number of bytes read if successful.',
                                                   'qualifiers': [],
                                                   'type': 'int'},
                                    'returnType': 'int',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                       'buf': ['*'],
                                                       'byteCount': ['unsigned']},
                                    'types': {'buf': 'void',
                                              'byteCount': 'uint'}}],
                           'getChunk': [{'argInfo': {'byteCount': {'doc': 'number of bytes in the chunk',
                                                                   'type': 'uint'},
                                                     'chunkTag': {'doc': "chunk's associated tag ",
                                                                  'type': 'MIffTag'}},
                                         'args': [('chunkTag',
                                                   'MIffTag',
                                                   'out'),
                                                  ('byteCount',
                                                   'uint',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nOpens a chunk for reading. A chunk is a block of unstructured data with an associated tag.',
                                         'inArgs': [],
                                         'outArgs': ['chunkTag',
                                                     'byteCount'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'byteCount': ['unsigned',
                                                                          '*'],
                                                            'chunkTag': ['&']},
                                         'types': {'byteCount': 'uint',
                                                   'chunkTag': 'MIffTag'}}],
                           'iffGetFloat': [{'argInfo': {'result': {'doc': 'the float value read from the file',
                                                                   'type': 'float'}},
                                            'args': [('result',
                                                      'float',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGrabs a float from the active file.',
                                            'inArgs': [],
                                            'outArgs': ['result'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'result': ['&']},
                                            'types': {'result': 'float'}}],
                           'iffGetInt': [{'argInfo': {'result': {'doc': 'the int value read from the file',
                                                                 'type': 'int'}},
                                          'args': [('result',
                                                    'int',
                                                    'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGrabs an integer from the active file.',
                                          'inArgs': [],
                                          'outArgs': ['result'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'result': ['&']},
                                          'types': {'result': 'int'}}],
                           'iffGetShort': [{'argInfo': {'result': {'doc': 'the short value read from the file',
                                                                   'type': 'short'}},
                                            'args': [('result',
                                                      'short',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGrabs a short from the active file.',
                                            'inArgs': [],
                                            'outArgs': ['result'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'result': ['int',
                                                                          '&']},
                                            'types': {'result': 'short'}}],
                           'isActive': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nIs the file currently active?',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                           'open': [{'argInfo': {'fileName': {'doc': 'The file name (full path).',
                                                              'type': 'MString'}},
                                     'args': [('fileName',
                                               'MString',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nOpens the file for reading.',
                                     'inArgs': ['fileName'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'fileName': ['const',
                                                                     '&']},
                                     'types': {'fileName': 'MString'}}]},
               'pymelEnums': {}},
  'MIffTag': {'enums': {},
              'methods': {'[static]': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nMarks the start of a group of data blocks containing properties shared between forms that are a part of a LIST \r\n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['MIffTag::kPROP'],
                                                       'type': 'MIffTag'},
                                        'returnType': 'MIffTag',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                          '__eq__': [{'argInfo': {'tag': {'doc': 'tag value to compare against ',
                                                          'type': 'MIffTag'}},
                                      'args': [('tag', 'MIffTag', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nEquals operator.',
                                      'inArgs': ['tag'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'tag': ['const',
                                                                 '&']},
                                      'types': {'tag': 'MIffTag'}}]},
              'pymelEnums': {}},
  'MIkHandleGroup': {'enums': {},
                     'invertibles': [('setSolverID', 'solverID'),
                                     ('setPriority', 'priority')],
                     'methods': {'checkEffectorAtGoal': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDetermines whether the end-effector at the handle(goal) location.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': ' true The end-effector is at the goal location  false The end-effector is not at the goal location  ',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'dofCount': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the total number of degrees of freedom of this handle group.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The total number of dofs',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'handle': [{'argInfo': {'ith': {'doc': 'the index of the handle ',
                                                                 'type': 'int'}},
                                             'args': [('ith',
                                                       'int',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the ith handle in the handle list for this group.',
                                             'inArgs': ['ith'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'An MObject for the handle',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'ith': []},
                                             'types': {'ith': 'int'}}],
                                 'handleCount': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the number of handles in the handle list for this group.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The number of handles',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'priority': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the priority value of this handle group.',
                                               'inArgs': [],
                                               'inverse': ('setPriority',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The priority',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'setPriority': [{'argInfo': {'priority': {'doc': 'the priority value to set',
                                                                           'type': 'int'}},
                                                  'args': [('priority',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the priority of this handle group.',
                                                  'inArgs': ['priority'],
                                                  'inverse': ('priority',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'priority': []},
                                                  'types': {'priority': 'int'}}],
                                 'setSolverID': [{'argInfo': {'id': {'doc': 'the id value to set',
                                                                     'type': 'int'}},
                                                  'args': [('id',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the solver id for this handle group.',
                                                  'inArgs': ['id'],
                                                  'inverse': ('solverID',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'id': []},
                                                  'types': {'id': 'int'}}],
                                 'solve': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nDo all ik solving steps for this group.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'solverID': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the solver id used by this handle group.',
                                               'inArgs': [],
                                               'inverse': ('setSolverID',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The solver id for this group',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'solverPriority': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nreturn the priority of the solver used by this handle group.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The solver priority',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'priority': 'getPriority',
                                      'solverID': 'getSolverID'}},
  'MIkSystem': {'enums': {},
                'invertibles': [('setGlobalSolve', 'isGlobalSolve'),
                                ('setGlobalSnap', 'isGlobalSnap')],
                'methods': {'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'findSolver': [{'argInfo': {'name': {'doc': 'the name of the solver to find ',
                                                                 'type': 'MString'}},
                                            'args': [('name',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns the ik solver with the given name. If the solver cannot be found then a a null  MObject  and an error is returned.',
                                            'inArgs': ['name'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The ik solver matching the given name',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': True,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'name': []},
                                            'types': {'name': 'MString'}}],
                            'getSolvers': [{'argInfo': {'names': {'doc': 'storage for the solver names',
                                                                  'type': 'MStringArray'}},
                                            'args': [('names',
                                                      'MStringArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nGet a list of the names for the solvers that are available in the system.',
                                            'inArgs': [],
                                            'outArgs': ['names'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'names': ['&']},
                                            'types': {'names': 'MStringArray'}}],
                            'isGlobalSnap': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nDetermines whether global snapping is on. Turning on global snapping will turn on snapping for all ik handles.',
                                              'inArgs': [],
                                              'inverse': ('setGlobalSnap',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': ' true global snapping is on  false global snapping is off  ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': True,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                            'isGlobalSolve': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nDetermines whether global solving is on.',
                                               'inArgs': [],
                                               'inverse': ('setGlobalSolve',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                            'setGlobalSnap': [{'argInfo': {'isSnap': {'doc': 'true turns global snapping on, false turns it off',
                                                                      'type': 'bool'}},
                                               'args': [('isSnap',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nTurns global snapping on or off. Turning on global snapping will turn on snapping for all ik handles.',
                                               'inArgs': ['isSnap'],
                                               'inverse': ('isGlobalSnap',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'isSnap': []},
                                               'types': {'isSnap': 'bool'}}],
                            'setGlobalSolve': [{'argInfo': {'isSolve': {'doc': 'true turns global solving on, false turns it off',
                                                                        'type': 'bool'}},
                                                'args': [('isSolve',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nTurns global solving on or off.',
                                                'inArgs': ['isSolve'],
                                                'inverse': ('isGlobalSolve',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'isSolve': []},
                                                'types': {'isSolve': 'bool'}}]},
                'pymelEnums': {}},
  'MImage': {'enums': {'MImageFilterFormat': {'valueDocs': {'heightFieldBumpFormat': '',
                                                            'kHeightFieldBumpFormat': '',
                                                            'kNoFormat': '',
                                                            'kNormalMapBumpFormat': '',
                                                            'kUnknownFormat': '',
                                                            'noFormat': '',
                                                            'normalMapBumpFormat': '',
                                                            'unknownFormat': ''},
                                              'values': "Enum('MImageFilterFormat', {'kNoFormat': 0, 'kHeightFieldBumpFormat': 1, 'kNormalMapBumpFormat': 2, 'kUnknownFormat': 3})"},
                       'MPixelType': {'valueDocs': {'byte': 'One byte per channel, ranging from 0 to 255.',
                                                    'float': 'One float per channel, ranging from 0.0 to 1.0.',
                                                    'kByte': 'One byte per channel, ranging from 0 to 255.',
                                                    'kFloat': 'One float per channel, ranging from 0.0 to 1.0.',
                                                    'kUnknown': 'Format not known or invalid.',
                                                    'unknown': 'Format not known or invalid.'},
                                      'values': "Enum('MPixelType', {'kUnknown': 0, 'kByte': 1, 'kFloat': 2})"}},
             'invertibles': [('setFloatPixels', 'floatPixels'),
                             ('setPixels', 'pixels'),
                             ('setRGBA', 'isRGBA'),
                             ('setDepthMap', 'depthMap')],
             'methods': {'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['*'],
                                                       'type': 'char'},
                                        'returnType': 'char',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'convertPixelFormat': [{'argInfo': {'format': {'doc': 'the desired pixel format. If this matches the current format, this method will do nothing. ',
                                                                        'type': ('MImage',
                                                                                 'MPixelType')},
                                                             'offset': {'doc': 'if conversion is required, this specifies the offset applied to every channel of every pixel.',
                                                                        'type': 'double'},
                                                             'scale': {'doc': 'if conversion is required, this specifies the scaling applied to every channel of every pixel. A scale of 0 will automatically rescale based on the minimum and maximum values in the image. ',
                                                                       'type': 'double'}},
                                                 'args': [('format',
                                                           ('MImage',
                                                            'MPixelType'),
                                                           'in'),
                                                          ('scale',
                                                           'double',
                                                           'in'),
                                                          ('offset',
                                                           'double',
                                                           'in')],
                                                 'defaults': {'offset': 0.0,
                                                              'scale': 1.0},
                                                 'deprecated': False,
                                                 'doc': '\r\nConvert the pixel format used by this image using the specified parameters.',
                                                 'inArgs': ['format',
                                                            'scale',
                                                            'offset'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'format': [],
                                                                    'offset': [],
                                                                    'scale': []},
                                                 'types': {'format': ('MImage',
                                                                      'MPixelType'),
                                                           'offset': 'double',
                                                           'scale': 'double'}}],
                         'create': [{'argInfo': {'channels': {'doc': 'the desired number of channels per pixel. For byte typed images, 4 channels is the only value currently supported. ',
                                                              'type': 'uint'},
                                                 'height': {'doc': "the desired image's height in pixels. ",
                                                            'type': 'uint'},
                                                 'type': {'doc': 'the desired pixel format.',
                                                          'type': ('MImage',
                                                                   'MPixelType')},
                                                 'width': {'doc': "the desired image's width in pixels. ",
                                                           'type': 'uint'}},
                                     'args': [('width', 'uint', 'in'),
                                              ('height', 'uint', 'in'),
                                              ('channels', 'uint', 'in'),
                                              ('type',
                                               ('MImage', 'MPixelType'),
                                               'in')],
                                     'defaults': {'channels': 4,
                                                  'type': ('MImage',
                                                           'MPixelType',
                                                           'kByte')},
                                     'deprecated': False,
                                     'doc': '\r\nCreate a new  MImage  object. Allocates memory for an RGBA array of pixels of the given size. If an object was already in memory, it is released first.',
                                     'inArgs': ['width',
                                                'height',
                                                'channels',
                                                'type'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'channels': ['unsigned'],
                                                        'height': ['unsigned'],
                                                        'type': [],
                                                        'width': ['unsigned']},
                                     'types': {'channels': 'uint',
                                               'height': 'uint',
                                               'type': ('MImage',
                                                        'MPixelType'),
                                               'width': 'uint'}}],
                         'depth': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nGet the color depth (in bytes) of the currently opened image.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'int'},
                                    'returnType': 'int',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                         'depthMap': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns a pointer to the depth data.',
                                       'inArgs': [],
                                       'inverse': ('setDepthMap', False),
                                       'outArgs': [],
                                       'returnInfo': {'doc': ' MS::kFailure - invalid object, or no depth data exists for this image instance.  MS::kSuccess - depth buffer successfully returned.   ',
                                                      'qualifiers': ['*'],
                                                      'type': 'float'},
                                       'returnType': 'float',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                         'filter': [{'argInfo': {'offset': {'doc': 'vary depending on the source/target format.',
                                                            'type': 'double'},
                                                 'scale': {'doc': 'vary depending on the source/target format. ',
                                                           'type': 'double'},
                                                 'sourceFormat': {'doc': 'the source format. ',
                                                                  'type': ('MImage',
                                                                           'MImageFilterFormat')},
                                                 'targetFormat': {'doc': 'desired target format. ',
                                                                  'type': ('MImage',
                                                                           'MImageFilterFormat')}},
                                     'args': [('sourceFormat',
                                               ('MImage',
                                                'MImageFilterFormat'),
                                               'in'),
                                              ('targetFormat',
                                               ('MImage',
                                                'MImageFilterFormat'),
                                               'in'),
                                              ('scale', 'double', 'in'),
                                              ('offset', 'double', 'in')],
                                     'defaults': {'offset': 0.0,
                                                  'scale': 1.0},
                                     'deprecated': False,
                                     'doc': '\r\nModify the content of the image by applying a filter. The dimension of the image remains the same; only the RGBA components get affected.',
                                     'inArgs': ['sourceFormat',
                                                'targetFormat',
                                                'scale',
                                                'offset'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'offset': [],
                                                        'scale': [],
                                                        'sourceFormat': [],
                                                        'targetFormat': []},
                                     'types': {'offset': 'double',
                                               'scale': 'double',
                                               'sourceFormat': ('MImage',
                                                                'MImageFilterFormat'),
                                               'targetFormat': ('MImage',
                                                                'MImageFilterFormat')}}],
                         'filterExists': [{'argInfo': {'sourceFormat': {'doc': 'the format of the source image.',
                                                                        'type': ('MImage',
                                                                                 'MImageFilterFormat')},
                                                       'targetFormat': {'doc': 'the format of the resulting image. ',
                                                                        'type': ('MImage',
                                                                                 'MImageFilterFormat')}},
                                           'args': [('sourceFormat',
                                                     ('MImage',
                                                      'MImageFilterFormat'),
                                                     'in'),
                                                    ('targetFormat',
                                                     ('MImage',
                                                      'MImageFilterFormat'),
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn whether or not a given source format can be directly converted to a given target format. See  MImage::filter()  for more information.',
                                           'inArgs': ['sourceFormat'],
                                           'outArgs': ['targetFormat'],
                                           'returnInfo': {'doc': ' true if the filter exists.  false otherwise.   ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': True,
                                           'typeQualifiers': {'sourceFormat': [],
                                                              'targetFormat': []},
                                           'types': {'sourceFormat': ('MImage',
                                                                      'MImageFilterFormat'),
                                                     'targetFormat': ('MImage',
                                                                      'MImageFilterFormat')}}],
                         'floatPixels': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns a pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth * sizeof( float)) bytes.',
                                          'inArgs': [],
                                          'inverse': ('setFloatPixels',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' Pointer to the first pixel of the array.  NULL if no image is currently opened, or the current image has a pixel type other than kFloat   ',
                                                         'qualifiers': ['*'],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                         'getDepthMapRange': [{'argInfo': {'maxValue': {'doc': 'Maximum value',
                                                                        'type': 'float'},
                                                           'minValue': {'doc': 'Minimum value ',
                                                                        'type': 'float'}},
                                               'args': [('minValue',
                                                         'float',
                                                         'out'),
                                                        ('maxValue',
                                                         'float',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nCompute the minimum and maximum depth values (range) for any stored depth buffer. The depth values returned are positive distances from the camera, with higher values indicating points further from the camera.',
                                               'inArgs': [],
                                               'outArgs': ['minValue',
                                                           'maxValue'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'maxValue': ['&'],
                                                                  'minValue': ['&']},
                                               'types': {'maxValue': 'float',
                                                         'minValue': 'float'}}],
                         'getDepthMapSize': [{'argInfo': {'height': {'doc': '- height of the depth map',
                                                                     'type': 'uint'},
                                                          'width': {'doc': '- width of the depth map ',
                                                                    'type': 'uint'}},
                                              'args': [('width',
                                                        'uint',
                                                        'out'),
                                                       ('height',
                                                        'uint',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the size of the depth map buffer. Note, depth maps can differ in resolution from the color map. This is mainly for oversampling support in image planes. In all other cases, you should insure that depth size matches the color buffer size. You cannot write out an image where the depth map and image map has different resolutions.',
                                              'inArgs': [],
                                              'outArgs': ['width',
                                                          'height'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'height': ['unsigned',
                                                                            '&'],
                                                                 'width': ['unsigned',
                                                                           '&']},
                                              'types': {'height': 'uint',
                                                        'width': 'uint'}}],
                         'getSize': [{'argInfo': {'height': {'doc': "the variable that will be set to the image's height in pixels.",
                                                             'type': 'uint'},
                                                  'width': {'doc': "the variable that will be set to the image's width in pixels. ",
                                                            'type': 'uint'}},
                                      'args': [('width', 'uint', 'out'),
                                               ('height', 'uint', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nGet the width and height of the currently opened image.',
                                      'inArgs': [],
                                      'outArgs': ['width', 'height'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'height': ['unsigned',
                                                                    '&'],
                                                         'width': ['unsigned',
                                                                   '&']},
                                      'types': {'height': 'uint',
                                                'width': 'uint'}}],
                         'haveDepth': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns true if this instance of  MImage  contains a depth map.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'bool'},
                                        'returnType': 'bool',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'isRGBA': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nQuery flag which indicates whether the pixel information is in RGBA sequence or BGRA sequence. If no pixel data exists, then false will be returned.',
                                     'inArgs': [],
                                     'inverse': ('setRGBA', False),
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                         'pixelType': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nGet the current pixel format of the image.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': ('MImage',
                                                                'MPixelType')},
                                        'returnType': ('MImage',
                                                       'MPixelType'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'pixels': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nReturns a pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth) bytes. For the moment, pixels are always stored in a RGBA (depth=4 bytes) pixel format.',
                                     'inArgs': [],
                                     'inverse': ('setPixels', False),
                                     'outArgs': [],
                                     'returnInfo': {'doc': ' Pointer to the first pixel of the array.  NULL if no image is currently opened, or the current image has a pixel type other than kByte   ',
                                                    'qualifiers': ['*'],
                                                    'type': 'char'},
                                     'returnType': 'char',
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                         'readDepthMap': [{'argInfo': {'pathname': {'doc': '- the path to the depth file.',
                                                                    'type': 'MString'}},
                                           'args': [('pathname',
                                                     'MString',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReads the depth map from the specified file and place the result into the depth map array of this  MImage  instance.',
                                           'inArgs': ['pathname'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'pathname': []},
                                           'types': {'pathname': 'MString'}}],
                         'readFromFile': [{'argInfo': {'pathname': {'doc': 'the full path of the image file that should be opened. ',
                                                                    'type': 'MString'},
                                                       'type': {'doc': 'the desired pixel format. kUnknown attempts to load the native pixel type.',
                                                                'type': ('MImage',
                                                                         'MPixelType')}},
                                           'args': [('pathname',
                                                     'MString',
                                                     'in'),
                                                    ('type',
                                                     ('MImage',
                                                      'MPixelType'),
                                                     'in')],
                                           'defaults': {'type': ('MImage',
                                                                 'MPixelType',
                                                                 'kByte')},
                                           'deprecated': False,
                                           'doc': '\r\nAttempt to identify and open the specified image file. Please note that IFF and SGI are the fastest image file formats for reading.',
                                           'inArgs': ['pathname', 'type'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'pathname': [],
                                                              'type': []},
                                           'types': {'pathname': 'MString',
                                                     'type': ('MImage',
                                                              'MPixelType')}}],
                         'readFromTextureNode': [{'argInfo': {'fileTextureObject': {'doc': 'an object that refers to the file texture node that should be read. ',
                                                                                    'type': 'MObject'},
                                                              'type': {'doc': 'the desired pixel format. kUnknown attempts to load the native image pixel type.',
                                                                       'type': ('MImage',
                                                                                'MPixelType')}},
                                                  'args': [('fileTextureObject',
                                                            'MObject',
                                                            'in'),
                                                           ('type',
                                                            ('MImage',
                                                             'MPixelType'),
                                                            'in')],
                                                  'defaults': {'type': ('MImage',
                                                                        'MPixelType',
                                                                        'kByte')},
                                                  'deprecated': False,
                                                  'doc': '\r\nAttempt to read the content of the given file texture node. Please note that IFF and SGI are the fastest image file formats for reading.',
                                                  'inArgs': ['fileTextureObject',
                                                             'type'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'fileTextureObject': ['const',
                                                                                           '&'],
                                                                     'type': []},
                                                  'types': {'fileTextureObject': 'MObject',
                                                            'type': ('MImage',
                                                                     'MPixelType')}}],
                         'release': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nRelease the current image. If there is no current image, the call is ignored. An image is always released automatically during destruction, so generally there is no need to call this function manually.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                         'resize': [{'argInfo': {'height': {'doc': 'the desired height in pixels. ',
                                                            'type': 'int'},
                                                 'preserveAspectRatio': {'doc': 'a boolean specifying whether the aspect ratio should be preserved or not. If this flag is set, the given width and height are interpreted as the maximum dimensions allowable.',
                                                                         'type': 'bool'},
                                                 'width': {'doc': 'the desired width in pixels. ',
                                                           'type': 'int'}},
                                     'args': [('width', 'int', 'in'),
                                              ('height', 'int', 'in'),
                                              ('preserveAspectRatio',
                                               'bool',
                                               'in')],
                                     'defaults': {'preserveAspectRatio': True},
                                     'deprecated': False,
                                     'doc': '\r\nResize the currently opened image to the specified dimension, or to the closest width/height that is preserves the original aspect ratio.',
                                     'inArgs': ['width',
                                                'height',
                                                'preserveAspectRatio'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'height': [],
                                                        'preserveAspectRatio': [],
                                                        'width': []},
                                     'types': {'height': 'int',
                                               'preserveAspectRatio': 'bool',
                                               'width': 'int'}}],
                         'setDepthMap': [{'argInfo': {'depth': {'doc': '- float buffer that contains depth values. The depth values should be stored as -1.0/eyeDistance, where eyeDistance == 0.0 implies no depth is at that location. ',
                                                                'type': 'float'},
                                                      'height': {'doc': '- the height of the depth buffer.',
                                                                 'type': 'uint'},
                                                      'width': {'doc': '- the width of the depth buffer ',
                                                                'type': 'uint'}},
                                          'args': [('depth',
                                                    'float',
                                                    'in'),
                                                   ('width',
                                                    'uint',
                                                    'in'),
                                                   ('height',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nSpecifies the depth map resolution and data. Note, it is possible for the depth map to be a different resolution from the color map. This is to support oversampling with image planes. You cannot save image data to a file if the color map and image maps are different resolutions.',
                                          'inArgs': ['depth',
                                                     'width',
                                                     'height'],
                                          'inverse': ('depthMap', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'depth': ['*'],
                                                             'height': ['unsigned'],
                                                             'width': ['unsigned']},
                                          'types': {'depth': 'float',
                                                    'height': 'uint',
                                                    'width': 'uint'}},
                                         {'argInfo': {'depth': {'doc': '- float array that contains depth values. The depth values should be stored as -1.0/eyeDistance, where eyeDistance == 0.0 implies no depth is at that location. ',
                                                                'type': 'MFloatArray'},
                                                      'height': {'doc': '- the height of the depth buffer.',
                                                                 'type': 'uint'},
                                                      'width': {'doc': '- the width of the depth buffer ',
                                                                'type': 'uint'}},
                                          'args': [('depth',
                                                    'MFloatArray',
                                                    'in'),
                                                   ('width',
                                                    'uint',
                                                    'in'),
                                                   ('height',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nSpecifies the depth map resolution and data. Note, it is possible for the depth map to be a different resolution from the color map. This is to support oversampling with image planes. You cannot save image data to a file if the color map and image maps are different resolutions.',
                                          'inArgs': ['depth',
                                                     'width',
                                                     'height'],
                                          'inverse': ('depthMap', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'depth': ['const',
                                                                       '&'],
                                                             'height': ['unsigned'],
                                                             'width': ['unsigned']},
                                          'types': {'depth': 'MFloatArray',
                                                    'height': 'uint',
                                                    'width': 'uint'}}],
                         'setFloatPixels': [{'argInfo': {'channels': {'doc': 'the number of channels per pixel. ',
                                                                      'type': 'uint'},
                                                         'height': {'doc': "the variable that will be set to the image's height in pixels. ",
                                                                    'type': 'uint'},
                                                         'inPixelPtr': {'doc': 'the variable containing a block of pixels. ',
                                                                        'type': 'float'},
                                                         'width': {'doc': "the variable that will be set to the image's width in pixels. ",
                                                                   'type': 'uint'}},
                                             'args': [('inPixelPtr',
                                                       'float',
                                                       'in'),
                                                      ('width',
                                                       'uint',
                                                       'in'),
                                                      ('height',
                                                       'uint',
                                                       'in'),
                                                      ('channels',
                                                       'uint',
                                                       'in')],
                                             'defaults': {'channels': 4},
                                             'deprecated': False,
                                             'doc': '\r\nSet the pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth) bytes. For the moment, pixels are always stored in a RGBA (depth=4 bytes) pixel format.',
                                             'inArgs': ['inPixelPtr',
                                                        'width',
                                                        'height',
                                                        'channels'],
                                             'inverse': ('floatPixels',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'channels': ['unsigned'],
                                                                'height': ['unsigned'],
                                                                'inPixelPtr': ['*'],
                                                                'width': ['unsigned']},
                                             'types': {'channels': 'uint',
                                                       'height': 'uint',
                                                       'inPixelPtr': 'float',
                                                       'width': 'uint'}}],
                         'setPixels': [{'argInfo': {'height': {'doc': "the variable that will be set to the image's height in pixels. ",
                                                               'type': 'uint'},
                                                    'inPixelPtr': {'doc': 'the variable containing a block of pixels. ',
                                                                   'type': 'uchar'},
                                                    'width': {'doc': "the variable that will be set to the image's width in pixels. ",
                                                              'type': 'uint'}},
                                        'args': [('inPixelPtr',
                                                  'uchar',
                                                  'in'),
                                                 ('width', 'uint', 'in'),
                                                 ('height',
                                                  'uint',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSet the pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth) bytes. For the moment, pixels are always stored in a RGBA (depth=4 bytes) pixel format.',
                                        'inArgs': ['inPixelPtr',
                                                   'width',
                                                   'height'],
                                        'inverse': ('pixels', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'height': ['unsigned'],
                                                           'inPixelPtr': ['unsigned',
                                                                          '*'],
                                                           'width': ['unsigned']},
                                        'types': {'height': 'uint',
                                                  'inPixelPtr': 'uchar',
                                                  'width': 'uint'}}],
                         'setRGBA': [{'argInfo': {'rgbaFormat': {'doc': 'true value indicates RGBA format ',
                                                                 'type': 'bool'}},
                                      'args': [('rgbaFormat',
                                                'bool',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSets a flag to indicate that pixel information is in RGBA sequence or BGRA sequence. Pixel data must have been allocated before this call is made.',
                                      'inArgs': ['rgbaFormat'],
                                      'inverse': ('isRGBA', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'rgbaFormat': []},
                                      'types': {'rgbaFormat': 'bool'}}],
                         'verticalFlip': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nFlips the image vertically. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'writeToFile': [{'argInfo': {'outputFormat': {'doc': 'the desired image format to save into. This follows the same convention found in the Render Globals window. Examples of valid formats include: als, bmp, cin, gif, jpg, rla, sgi, tga, tif. "iff" is the default, and is the fastest format to save into since it doesn\'t need any internal conversion.',
                                                                       'type': 'MString'},
                                                      'pathname': {'doc': 'a path to the desired file. This path can be absolute (eg: "C:/temp/bump.iff") or relative (eg: "temp/bump.iff").',
                                                                   'type': 'MString'}},
                                          'args': [('pathname',
                                                    'MString',
                                                    'in'),
                                                   ('outputFormat',
                                                    'MString',
                                                    'in')],
                                          'defaults': {'outputFormat': 'MString("iff")'},
                                          'deprecated': False,
                                          'doc': '\r\nSave the content of this image in a file. By default, the file is saved in IFF format. Optionally, the file can also be converted in a variety of image formats.',
                                          'inArgs': ['pathname',
                                                     'outputFormat'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'outputFormat': [],
                                                             'pathname': []},
                                          'types': {'outputFormat': 'MString',
                                                    'pathname': 'MString'}}],
                         'writeToFileWithDepth': [{'argInfo': {'outputFormat': {'doc': 'the desired image format to save into. This follows the same convention found in the Render Globals window. Examples of valid formats include: als, bmp, cin, gif, jpg, rla, sgi, tga, tif. "iff" is the default, and is the fastest format to save into since it doesn\'t need any internal conversion.',
                                                                                'type': 'MString'},
                                                               'pathname': {'doc': 'a path to the desired file. This path can be absolute (eg: "C:/temp/bump.iff") or relative (eg: "temp/bump.iff").',
                                                                            'type': 'MString'},
                                                               'writeDepth': {'doc': 'writes the depth channel information if it stored in the class data.',
                                                                              'type': 'bool'}},
                                                   'args': [('pathname',
                                                             'MString',
                                                             'in'),
                                                            ('outputFormat',
                                                             'MString',
                                                             'in'),
                                                            ('writeDepth',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'outputFormat': 'MString("iff")',
                                                                'writeDepth': False},
                                                   'deprecated': False,
                                                   'doc': '\r\nSave the content of this image in a file. By default, the file is saved in IFF format. Optionally, the file can also be converted in a variety of image formats. If the writeDepth parameter is true then any depth information stored in  MImage  will be written to file.',
                                                   'inArgs': ['pathname',
                                                              'outputFormat',
                                                              'writeDepth'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'outputFormat': [],
                                                                      'pathname': [],
                                                                      'writeDepth': []},
                                                   'types': {'outputFormat': 'MString',
                                                             'pathname': 'MString',
                                                             'writeDepth': 'bool'}}]},
             'pymelEnums': {'MImageFilterFormat': "Enum('MImageFilterFormat', [('noFormat', 0), ('kNoFormat', 0), ('heightFieldBumpFormat', 1), ('kHeightFieldBumpFormat', 1), ('normalMapBumpFormat', 2), ('kNormalMapBumpFormat', 2), ('unknownFormat', 3), ('kUnknownFormat', 3)], multiKeys=True)",
                            'MPixelType': "Enum('MPixelType', [('unknown', 0), ('kUnknown', 0), ('byte', 1), ('kByte', 1), ('float', 2), ('kFloat', 2)], multiKeys=True)"},
             'pymelMethods': {'depthMap': 'getDepthMap',
                              'floatPixels': 'getFloatPixels',
                              'pixels': 'getPixels'}},
  'MImageFileInfo': {'enums': {'MHwTextureType': {'valueDocs': {'kHwTexture1D': '',
                                                                'kHwTexture2D': '',
                                                                'kHwTexture3D': '',
                                                                'kHwTextureCubeMap': '',
                                                                'kHwTextureRectangle': '',
                                                                'kHwTextureUnknown': '',
                                                                'texture1D': '',
                                                                'texture2D': '',
                                                                'texture3D': '',
                                                                'textureCubeMap': '',
                                                                'textureRectangle': '',
                                                                'textureUnknown': ''},
                                                  'values': "Enum('MHwTextureType', {'kHwTextureUnknown': 0, 'kHwTexture1D': 1, 'kHwTexture2D': 2, 'kHwTexture3D': 3, 'kHwTextureRectangle': 4, 'kHwTextureCubeMap': 5})"},
                               'MImageType': {'valueDocs': {'bump': '',
                                                            'color': '',
                                                            'kImageTypeBump': '',
                                                            'kImageTypeColor': '',
                                                            'kImageTypeNormal': '',
                                                            'kImageTypeUnknown': '',
                                                            'normal': '',
                                                            'unknown': ''},
                                              'values': "Enum('MImageType', {'kImageTypeUnknown': 0, 'kImageTypeColor': 1, 'kImageTypeNormal': 2, 'kImageTypeBump': 3})"}},
                     'methods': {'channels': [{'argInfo': {'value': {'doc': 'the number of channels per pixel ',
                                                                     'type': 'uint'}},
                                               'args': [('value',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet the number of channels per pixels in this image file.',
                                               'inArgs': ['value'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'value': ['unsigned']},
                                               'types': {'value': 'uint'}},
                                              {'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the number of channels in this image file.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'hardwareType': [{'argInfo': {'value': {'doc': 'the hardware texture type of this image file ',
                                                                         'type': ('MImageFileInfo',
                                                                                  'MHwTextureType')}},
                                                   'args': [('value',
                                                             ('MImageFileInfo',
                                                              'MHwTextureType'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the hardware texture type of this image file, configuring whether this image contains a 2D texture, a cubemap, etc.',
                                                   'inArgs': ['value'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'value': []},
                                                   'types': {'value': ('MImageFileInfo',
                                                                       'MHwTextureType')}},
                                                  {'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the hardware texture type of this image file, describing whether this image contains a 2D texture, a cubemap, etc.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': ('MImageFileInfo',
                                                                           'MHwTextureType')},
                                                   'returnType': ('MImageFileInfo',
                                                                  'MHwTextureType'),
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'hasAlpha': [{'argInfo': {'value': {'doc': 'true if the image contains alpha, false otherwise. ',
                                                                     'type': 'bool'}},
                                               'args': [('value',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSet whether or not this image file contains alpha.',
                                               'inArgs': ['value'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'value': []},
                                               'types': {'value': 'bool'}},
                                              {'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nQuery whether this image contains alpha information.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'hasMipMaps': [{'argInfo': {'value': {'doc': 'true if the image contains or can generate mipmaps, false otherwise. ',
                                                                       'type': 'bool'}},
                                                 'args': [('value',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet whether or not this image file contains or can generate mipmaps.',
                                                 'inArgs': ['value'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'value': []},
                                                 'types': {'value': 'bool'}},
                                                {'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nQuery whether this image contains or can generate mipmap information.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                 'height': [{'argInfo': {'value': {'doc': 'the height in pixels ',
                                                                   'type': 'uint'}},
                                             'args': [('value',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the height in pixels of this image file.',
                                             'inArgs': ['value'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'value': ['unsigned']},
                                             'types': {'value': 'uint'}},
                                            {'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the height in pixels of this image file.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                 'imageType': [{'argInfo': {'value': {'doc': 'the type of information in this image file ',
                                                                      'type': ('MImageFileInfo',
                                                                               'MImageType')}},
                                                'args': [('value',
                                                          ('MImageFileInfo',
                                                           'MImageType'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet the type of information stored in this image file (e.g. the image contains a color map, a bump map, etc). This is an optional call as most image file formats do not describe the semantic use of the pixels they contains. In such cases it is safe to leave this as the default value of kImageTypeUnknown.',
                                                'inArgs': ['value'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': ('MImageFileInfo',
                                                                    'MImageType')}},
                                               {'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nQuery the type of information in this image file (e.g. is it a color map, a normal map, etc). Most image file formats do not contain this information, meaning this will be left as kImageTypeUnknown.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MImageFileInfo',
                                                                        'MImageType')},
                                                'returnType': ('MImageFileInfo',
                                                               'MImageType'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'numberOfImages': [{'argInfo': {'value': {'doc': 'the number of images ',
                                                                           'type': 'uint'}},
                                                     'args': [('value',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the total number of images in this image file.',
                                                     'inArgs': ['value'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'value': ['unsigned']},
                                                     'types': {'value': 'uint'}},
                                                    {'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the number of images in this image file.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                 'pixelType': [{'argInfo': {'value': {'doc': 'the native pixel format of this image file ',
                                                                      'type': ('MImage',
                                                                               'MPixelType')}},
                                                'args': [('value',
                                                          ('MImage',
                                                           'MPixelType'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSet the native pixel format of this image file.',
                                                'inArgs': ['value'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'value': []},
                                                'types': {'value': ('MImage',
                                                                    'MPixelType')}},
                                               {'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the native pixel format of this image file.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': ('MImage',
                                                                        'MPixelType')},
                                                'returnType': ('MImage',
                                                               'MPixelType'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'width': [{'argInfo': {'value': {'doc': 'the width in pixels ',
                                                                  'type': 'uint'}},
                                            'args': [('value',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the width in pixels of this image file.',
                                            'inArgs': ['value'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'value': ['unsigned']},
                                            'types': {'value': 'uint'}},
                                           {'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGet the width in pixels of this image file.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                     'pymelEnums': {'MHwTextureType': "Enum('MHwTextureType', [('textureUnknown', 0), ('kHwTextureUnknown', 0), ('texture1D', 1), ('kHwTexture1D', 1), ('texture2D', 2), ('kHwTexture2D', 2), ('texture3D', 3), ('kHwTexture3D', 3), ('textureRectangle', 4), ('kHwTextureRectangle', 4), ('textureCubeMap', 5), ('kHwTextureCubeMap', 5)], multiKeys=True)",
                                    'MImageType': "Enum('MImageType', [('unknown', 0), ('kImageTypeUnknown', 0), ('color', 1), ('kImageTypeColor', 1), ('normal', 2), ('kImageTypeNormal', 2), ('bump', 3), ('kImageTypeBump', 3)], multiKeys=True)"}},
  'MInt64Array': {'enums': {},
                  'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                  ('setLength', 'length')],
                  'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nNO SCRIPT SUPPORT. \n',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the indicated element ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MInt64'},
                                               'returnType': 'MInt64',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}},
                                              {'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nNO SCRIPT SUPPORT. \n',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the indicated element. ',
                                                              'qualifiers': [],
                                                              'type': 'MInt64'},
                                               'returnType': 'MInt64',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                              'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                  'type': 'MInt64'}},
                                          'args': [('element',
                                                    'MInt64',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': []},
                                          'types': {'element': 'MInt64'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'clear': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                               'type': 'MInt64Array'}},
                                        'args': [('source',
                                                  'MInt64Array',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nCopy the contents of the source array to this array.',
                                        'inArgs': ['source'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'source': ['const',
                                                                      '&']},
                                        'types': {'source': 'MInt64Array'}}],
                              'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                             'type': 'MInt64__array'}},
                                       'args': [('array',
                                                 'MInt64__array',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nCopy the elements of the array into the given C++ array of ints. No checking is done to ensure that the destination C++ array of 64-bit ints is large enough to hold all the elements of the instance.',
                                       'inArgs': [],
                                       'outArgs': ['array'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'array': []},
                                       'types': {'array': 'MInt64__array'}}],
                              'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                  'type': 'MInt64'},
                                                      'index': {'doc': 'the index of the element to set to the the new value',
                                                                'type': 'uint'}},
                                          'args': [('element',
                                                    'MInt64',
                                                    'in'),
                                                   ('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element', 'index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': [],
                                                             'index': ['unsigned']},
                                          'types': {'element': 'MInt64',
                                                    'index': 'uint'}}],
                              'length': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns the number of elements in the instance.',
                                          'inArgs': [],
                                          'inverse': ('setLength', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                'type': 'uint'}},
                                          'args': [('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                          'inArgs': ['index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'index': ['unsigned']},
                                          'types': {'index': 'uint'}}],
                              'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                               'type': 'MInt64'},
                                                   'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'}},
                                       'args': [('element',
                                                 'MInt64',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nSets the value of the indicated element to the indicated value.',
                                       'inArgs': ['element', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'element': [],
                                                          'index': ['unsigned']},
                                       'types': {'element': 'MInt64',
                                                 'index': 'uint'}}],
                              'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                    'type': 'uint'}},
                                             'args': [('length',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                             'inArgs': ['length'],
                                             'inverse': ('length', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'length': ['unsigned']},
                                             'types': {'length': 'uint'}}],
                              'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                 'type': 'uint'}},
                                                    'args': [('newIncrement',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                    'inArgs': ['newIncrement'],
                                                    'inverse': ('sizeIncrement',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'newIncrement': ['unsigned']},
                                                    'types': {'newIncrement': 'uint'}}],
                              'sizeIncrement': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                 'inArgs': [],
                                                 'inverse': ('setSizeIncrement',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'length': 'getLength',
                                   'sizeIncrement': 'getSizeIncrement'}},
  'MIntArray': {'enums': {},
                'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                ('setLength', 'length')],
                'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                   'type': 'uint'}},
                                             'args': [('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                             'inArgs': ['index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the indicated element ',
                                                            'qualifiers': ['&'],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {'index': ['unsigned']},
                                             'types': {'index': 'uint'}},
                                            {'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                   'type': 'uint'}},
                                             'args': [('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                             'inArgs': ['index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The value of the indicated element. ',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {'index': ['unsigned']},
                                             'types': {'index': 'uint'}}],
                            'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                'type': 'int'}},
                                        'args': [('element',
                                                  'int',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                        'inArgs': ['element'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': []},
                                        'types': {'element': 'int'}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'clear': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                            'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                             'type': 'MIntArray'}},
                                      'args': [('source',
                                                'MIntArray',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nCopy the contents of the source array to this array.',
                                      'inArgs': ['source'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'source': ['const',
                                                                    '&']},
                                      'types': {'source': 'MIntArray'}}],
                            'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                           'type': 'int__array'}},
                                     'args': [('array',
                                               'int__array',
                                               'out')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nCopy the elements of the array into the given C++ array of ints. No checking is done to ensure that the destination C++ array of ints is large enough to hold all the elements of the instance.',
                                     'inArgs': [],
                                     'outArgs': ['array'],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'array': []},
                                     'types': {'array': 'int__array'}}],
                            'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                'type': 'int'},
                                                    'index': {'doc': 'the index of the element to set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'int',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': [],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'int',
                                                  'index': 'uint'}}],
                            'length': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the number of elements in the instance.',
                                        'inArgs': [],
                                        'inverse': ('setLength', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The number of elements in the instance ',
                                                       'qualifiers': [],
                                                       'type': 'int'},
                                        'returnType': 'int',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                            'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                              'type': 'uint'}},
                                        'args': [('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                        'inArgs': ['index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'index': ['unsigned']},
                                        'types': {'index': 'uint'}}],
                            'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                             'type': 'int'},
                                                 'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                           'type': 'uint'}},
                                     'args': [('element', 'int', 'in'),
                                              ('index', 'uint', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nSets the value of the indicated element to the indicated value.',
                                     'inArgs': ['element', 'index'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'element': [],
                                                        'index': ['unsigned']},
                                     'types': {'element': 'int',
                                               'index': 'uint'}}],
                            'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                  'type': 'uint'}},
                                           'args': [('length',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                           'inArgs': ['length'],
                                           'inverse': ('length', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'length': ['unsigned']},
                                           'types': {'length': 'uint'}}],
                            'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                               'type': 'uint'}},
                                                  'args': [('newIncrement',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                  'inArgs': ['newIncrement'],
                                                  'inverse': ('sizeIncrement',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'newIncrement': ['unsigned']},
                                                  'types': {'newIncrement': 'uint'}}],
                            'sizeIncrement': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                               'inArgs': [],
                                               'inverse': ('setSizeIncrement',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                'pymelEnums': {},
                'pymelMethods': {'length': 'getLength',
                                 'sizeIncrement': 'getSizeIncrement'}},
  'MItCurveCV': {'enums': {},
                 'invertibles': [('setPosition', 'position')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'currentItem': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method returns the current CV as an  MObject .',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A handle to the CV requested',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                             'cv': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': '\n This method is obsolete. \n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'A handle to the CV requested',
                                                    'qualifiers': [],
                                                    'type': 'MObject'},
                                     'returnType': 'MObject',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}}],
                             'hasHistoryOnCreate': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method determines if the shape was created with history.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Boolean value: true if shape has history, false otherwise.',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                             'index': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThis method returns the index of the current CV in the CV array for this curve.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The index of the current CV',
                                                       'qualifiers': [],
                                                       'type': 'int'},
                                        'returnType': 'int',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                             'isDone': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns  true  if the iteration is finished, i.e. there are no more CVs to iterate on.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Boolean value: true if there are no more CVs to iterate on, false otherwise.',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                             'next': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nAdvance to the next CV in the iteration. If the iterator is already at the last CV then this method has no effect. Use  isDone  to determine if the iterator is at the last CV.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                             'position': [{'argInfo': {'space': {'doc': 'the co-oordinate system for the returned point ',
                                                                 'type': ('MSpace',
                                                                          'Space')}},
                                           'args': [('space',
                                                     ('MSpace',
                                                      'Space'),
                                                     'in')],
                                           'defaults': {'space': ('MSpace',
                                                                  'Space',
                                                                  'kObject')},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the position of the current CV.',
                                           'inArgs': ['space'],
                                           'inverse': ('setPosition',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Status code',
                                                          'qualifiers': [],
                                                          'type': 'MPoint'},
                                           'returnType': 'MPoint',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'space': []},
                                           'types': {'space': ('MSpace',
                                                               'Space')}}],
                             'reset': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReset the iterator to the first CV.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}},
                                       {'argInfo': {'curve': {'doc': 'The curve for the iteration',
                                                              'type': 'MObject'}},
                                        'args': [('curve',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReset the iterator to the specified curve.',
                                        'inArgs': ['curve'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'curve': ['&']},
                                        'types': {'curve': 'MObject'}},
                                       {'argInfo': {'component': {'doc': 'A group of CVs to be iterated on',
                                                                  'type': 'MObject'},
                                                    'curve': {'doc': 'Dag path to the curve for the iteration ',
                                                              'type': 'MDagPath'}},
                                        'args': [('curve',
                                                  'MDagPath',
                                                  'in'),
                                                 ('component',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {'component': 'MObject::kNullObj'},
                                        'deprecated': False,
                                        'doc': '\r\nReset the iterator to the specified curve and component. The component is a group of CVs belonging to the specified curve. The component defaults to  MObject::kNullObj . If a component is not given then the iterator will be reset for the whole curve.',
                                        'inArgs': ['curve', 'component'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'component': ['&'],
                                                           'curve': ['const',
                                                                     '&']},
                                        'types': {'component': 'MObject',
                                                  'curve': 'MDagPath'}}],
                             'setPosition': [{'argInfo': {'pt': {'doc': 'new position of CV ',
                                                                 'type': 'MPoint'},
                                                          'space': {'doc': 'the co-ordinate system for this transformation.',
                                                                    'type': ('MSpace',
                                                                             'Space')}},
                                              'args': [('pt',
                                                        'MPoint',
                                                        'in'),
                                                       ('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': '\r\nSet the position of the current CV to the specified point.',
                                              'inArgs': ['pt', 'space'],
                                              'inverse': ('position',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'pt': ['const',
                                                                        '&'],
                                                                 'space': []},
                                              'types': {'pt': 'MPoint',
                                                        'space': ('MSpace',
                                                                  'Space')}}],
                             'translateBy': [{'argInfo': {'space': {'doc': 'the co-oordinate system for this transformation.',
                                                                    'type': ('MSpace',
                                                                             'Space')},
                                                          'vec': {'doc': 'translation to be applied to the CV ',
                                                                  'type': 'MVector'}},
                                              'args': [('vec',
                                                        'MVector',
                                                        'in'),
                                                       ('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': '\r\nTranslates the current CV by the amount specified in  vec .',
                                              'inArgs': ['vec', 'space'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'space': [],
                                                                 'vec': ['const',
                                                                         '&']},
                                              'types': {'space': ('MSpace',
                                                                  'Space'),
                                                        'vec': 'MVector'}}],
                             'updateCurve': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method is used to signal the curve that it has been changed and needs to redraw itself.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'position': 'getPosition'}},
  'MItDependencyGraph': {'enums': {'Direction': {'valueDocs': {'downstream': 'From source to destination.',
                                                               'kDownstream': 'From source to destination.',
                                                               'kUpstream': 'From destination to source.',
                                                               'upstream': 'From destination to source.'},
                                                 'values': "Enum('Direction', {'kDownstream': 0, 'kUpstream': 1})"},
                                   'Level': {'valueDocs': {'kNodeLevel': 'Visit each Node at most once.',
                                                           'kPlugLevel': 'Visit each Plug at most once.',
                                                           'nodeLevel': 'Visit each Node at most once.',
                                                           'plugLevel': 'Visit each Plug at most once.'},
                                             'values': "Enum('Level', {'kNodeLevel': 0, 'kPlugLevel': 1})"},
                                   'Traversal': {'valueDocs': {'breadthFirst': 'Equidistant from root first.',
                                                               'depthFirst': 'Away from root first.',
                                                               'kBreadthFirst': 'Equidistant from root first.',
                                                               'kDepthFirst': 'Away from root first.'},
                                                 'values': "Enum('Traversal', {'kDepthFirst': 0, 'kBreadthFirst': 1})"}},
                         'invertibles': [('setCurrentFilter',
                                          'currentFilter')],
                         'methods': {'atNodeLevel': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nTests whether or not the iteration is at the node level of detail (every node is visited only once) in the DG.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': ' true node level (MItDependencyGraph::kNodeLevel)  false plug level (MItDependencyGraph::kPlugLevel)  ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'currentDirection': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReports the direction of the iteration through the graph.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' MItDependencyGraph::kDownstream Direction is downstream  MItDependencyGraph::kDownstream Direction is upstream  ',
                                                                          'qualifiers': [],
                                                                          'type': ('MItDependencyGraph',
                                                                                   'Direction')},
                                                           'returnType': ('MItDependencyGraph',
                                                                          'Direction'),
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                     'currentFilter': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRetrieves the current node type filter.',
                                                        'inArgs': [],
                                                        'inverse': ('setCurrentFilter',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The current node type filter',
                                                                       'qualifiers': [],
                                                                       'type': ('MFn',
                                                                                'Type')},
                                                        'returnType': ('MFn',
                                                                       'Type'),
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                        'types': {}}],
                                     'currentItem': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nRetrieves the current node of the iteration. Results in a null object on failure or if the node is of a unrecognized type.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Current node',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                     'currentLevel': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReports the level of the iteration through the graph.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': ' MItDependencyGraph::kNodeLevel Level is node level  MItDependencyGraph::kPlugLevel Level is plug level  ',
                                                                      'qualifiers': [],
                                                                      'type': ('MItDependencyGraph',
                                                                               'Level')},
                                                       'returnType': ('MItDependencyGraph',
                                                                      'Level'),
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                     'currentTraversal': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReports the traversal mode of the iteration through the graph.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': ' MItDependencyGraph::kDepthFirst Traversal is depth first  MItDependencyGraph::kBreadthFirst Traversal is breadth first  ',
                                                                          'qualifiers': [],
                                                                          'type': ('MItDependencyGraph',
                                                                                   'Traversal')},
                                                           'returnType': ('MItDependencyGraph',
                                                                          'Traversal'),
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                     'disablePruningOnFilter': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nDisables automatic pruning of iteration path at nodes or plugs which do not match the filter.',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                     'enablePruningOnFilter': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nEnables automatic pruning of iteration path at nodes or plugs which do not match the filter.',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                                     'getNodePath': [{'argInfo': {'path': {'doc': 'Target array for retrieved path. On success contains direct path from the current node to the root node',
                                                                           'type': 'MObjectArray'}},
                                                      'args': [('path',
                                                                'MObjectArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nRetrieves the direct path from the current node to the root node. Path does not include the current node. State of the provided array is undefined if this method fails.',
                                                      'inArgs': [],
                                                      'outArgs': ['path'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'path': ['&']},
                                                      'types': {'path': 'MObjectArray'}}],
                                     'getNodesVisited': [{'argInfo': {'nodes': {'doc': 'Target array for retrieved nodes. On success contains all nodes visited',
                                                                                'type': 'MObjectArray'}},
                                                          'args': [('nodes',
                                                                    'MObjectArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nRetrieves all nodes visited during the iteration. State of the provided array is undefined if this method fails.',
                                                          'inArgs': [],
                                                          'outArgs': ['nodes'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'nodes': ['&']},
                                                          'types': {'nodes': 'MObjectArray'}}],
                                     'getPlugPath': [{'argInfo': {'path': {'doc': 'Target array for retrieved path. On success contains direct path from the current plug to the root plug',
                                                                           'type': 'MPlugArray'}},
                                                      'args': [('path',
                                                                'MPlugArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nRetrieves the direct path from the current plug to the root plug, with the current plug in element 0 of the array and the root plug in the final element of the array.',
                                                      'inArgs': [],
                                                      'outArgs': ['path'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'path': ['&']},
                                                      'types': {'path': 'MPlugArray'}}],
                                     'getPlugsVisited': [{'argInfo': {'plugs': {'doc': 'Target array for retrieved plugs. On success contains all plugs visited',
                                                                                'type': 'MPlugArray'}},
                                                          'args': [('plugs',
                                                                    'MPlugArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nRetrieves all plugs visited during the iteration. State of the provided array is undefined if this method fails.',
                                                          'inArgs': [],
                                                          'outArgs': ['plugs'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'plugs': ['&']},
                                                          'types': {'plugs': 'MPlugArray'}}],
                                     'isDirectionDownStream': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nTests whether or not the iteration is moving downstream (in the direction of data flow) in the DG.',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': ' true Direction is downstream (MItDependencyGraph::kDownstream)  false Direction is upstream (MItDependencyGraph::kUpstream)  ',
                                                                               'qualifiers': [],
                                                                               'type': 'bool'},
                                                                'returnType': 'bool',
                                                                'static': False,
                                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                                'types': {}}],
                                     'isDone': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nIndicates whether or not all nodes or plugs have been iterated over in accordance with the direction, traversal, level and filter. If a valid filter is set, the iterator only visits those nodes that match the filter.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true Iteration is done  false Iteration is not done  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                     'isPruningOnFilter': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nTests whether or not the iteration path is pruned automatically at nodes or plugs which do not match the filter.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Bool: true if pruning is enabled, false otherwise.',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                     'isTraversalDepthFirst': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nTests whether or not the iteration is proceeding depth first (away from the root of the iteration) in the DG.',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': ' true Traversal is depth first (MItDependencyGraph::kDepthFirst)  false Traversal is breadth first (MItDependencyGraph::kBreadthFirst)  ',
                                                                               'qualifiers': [],
                                                                               'type': 'bool'},
                                                                'returnType': 'bool',
                                                                'static': False,
                                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                                'types': {}}],
                                     'isTraversingOverWorldSpaceDependents': [{'argInfo': {},
                                                                               'args': [],
                                                                               'defaults': {},
                                                                               'deprecated': False,
                                                                               'doc': '\r\nTests whether the iterator is set to traverse world-space attribute dependencies.',
                                                                               'inArgs': [],
                                                                               'outArgs': [],
                                                                               'returnInfo': {'doc': ' true Traversing of world-space attributes is enabled.  false Traversing of world-space attributes is disabled.  ',
                                                                                              'qualifiers': [],
                                                                                              'type': 'bool'},
                                                                               'returnType': 'bool',
                                                                               'static': False,
                                                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                                                               'types': {}}],
                                     'next': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nIterates to the next node or plug in accordance with the direction, traversal, level and filter. If a valid filter is set, the iterator only visits those nodes that match the filter. When filtering is enabled nodes that have unknown type are treated as non-matching nodes. With filtering disabled, iteration to a node with an unknown type is treated as a failure. An attempt to iterate when there is nothing left to iterate over has no effect.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                     'previousPlug': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nRetrieves the previous plug of the iteration. Results in a null plug on failure. Null plug may also indicate that the current plug is the root plug.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': ' Current plug  ',
                                                                      'qualifiers': [],
                                                                      'type': 'MPlug'},
                                                       'returnType': 'MPlug',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                     'prune': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nPrunes the search path at the current plug. Iterator will not visit any of the plugs connected to the pruned plug.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                     'reset': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nClears iterator data and resets the iterator to the root node or plug. If a valid filter is enabled, the iterator automatically advances to the next node after the root node that matches the filter. If no matching node is found the status is failure (MFn::kFailure).',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                     'resetFilter': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nResets the node or plug filter to default,  MFn::kInvalid  (filter disabled). Disables pruning on the filter (default). Resets the iterator.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                     'resetTo': [{'argInfo': {'direction': {'doc': 'Primary direction of iteration',
                                                                            'type': ('MItDependencyGraph',
                                                                                     'Direction')},
                                                              'filter': {'doc': 'Object type filter (see MFn::Type) ',
                                                                         'type': ('MFn',
                                                                                  'Type')},
                                                              'level': {'doc': 'Level of detail of the iteration',
                                                                        'type': ('MItDependencyGraph',
                                                                                 'Level')},
                                                              'rootNode': {'doc': 'Root node of the iteration ',
                                                                           'type': 'MObject'},
                                                              'traversal': {'doc': 'Order of traversal ',
                                                                            'type': ('MItDependencyGraph',
                                                                                     'Traversal')}},
                                                  'args': [('rootNode',
                                                            'MObject',
                                                            'in'),
                                                           ('filter',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('direction',
                                                            ('MItDependencyGraph',
                                                             'Direction'),
                                                            'in'),
                                                           ('traversal',
                                                            ('MItDependencyGraph',
                                                             'Traversal'),
                                                            'in'),
                                                           ('level',
                                                            ('MItDependencyGraph',
                                                             'Level'),
                                                            'in')],
                                                  'defaults': {'direction': ('MItDependencyGraph',
                                                                             'Direction',
                                                                             'kDownstream'),
                                                               'filter': ('MFn',
                                                                          'Type',
                                                                          'kInvalid'),
                                                               'level': ('MItDependencyGraph',
                                                                         'Level',
                                                                         'kNodeLevel'),
                                                               'traversal': ('MItDependencyGraph',
                                                                             'Traversal',
                                                                             'kDepthFirst')},
                                                  'deprecated': False,
                                                  'doc': '\r\nClears iterator data and re-initializes the iterator. If a valid filter is provided, the iterator automatically advances to the next node after the root node that matches the filter. If no matching node is found the status is failure (MFn::kFailure).',
                                                  'inArgs': ['rootNode',
                                                             'filter',
                                                             'direction',
                                                             'traversal',
                                                             'level'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'direction': [],
                                                                     'filter': [],
                                                                     'level': [],
                                                                     'rootNode': ['&'],
                                                                     'traversal': []},
                                                  'types': {'direction': ('MItDependencyGraph',
                                                                          'Direction'),
                                                            'filter': ('MFn',
                                                                       'Type'),
                                                            'level': ('MItDependencyGraph',
                                                                      'Level'),
                                                            'rootNode': 'MObject',
                                                            'traversal': ('MItDependencyGraph',
                                                                          'Traversal')}},
                                                 {'argInfo': {'direction': {'doc': 'Primary direction of iteration',
                                                                            'type': ('MItDependencyGraph',
                                                                                     'Direction')},
                                                              'filter': {'doc': 'Object type filter (see MFn::Type) ',
                                                                         'type': ('MFn',
                                                                                  'Type')},
                                                              'level': {'doc': 'Level of detail of the iteration',
                                                                        'type': ('MItDependencyGraph',
                                                                                 'Level')},
                                                              'rootPlug': {'doc': 'Root plug of the iteration ',
                                                                           'type': 'MPlug'},
                                                              'traversal': {'doc': 'Order of traversal',
                                                                            'type': ('MItDependencyGraph',
                                                                                     'Traversal')}},
                                                  'args': [('rootPlug',
                                                            'MPlug',
                                                            'in'),
                                                           ('filter',
                                                            ('MFn',
                                                             'Type'),
                                                            'in'),
                                                           ('direction',
                                                            ('MItDependencyGraph',
                                                             'Direction'),
                                                            'in'),
                                                           ('traversal',
                                                            ('MItDependencyGraph',
                                                             'Traversal'),
                                                            'in'),
                                                           ('level',
                                                            ('MItDependencyGraph',
                                                             'Level'),
                                                            'in')],
                                                  'defaults': {'direction': ('MItDependencyGraph',
                                                                             'Direction',
                                                                             'kDownstream'),
                                                               'filter': ('MFn',
                                                                          'Type',
                                                                          'kInvalid'),
                                                               'level': ('MItDependencyGraph',
                                                                         'Level',
                                                                         'kPlugLevel'),
                                                               'traversal': ('MItDependencyGraph',
                                                                             'Traversal',
                                                                             'kDepthFirst')},
                                                  'deprecated': False,
                                                  'doc': '\r\nClears iterator data and re-initializes the iterator. If a valid filter is enabled, the iterator automatically advances to the next node after the root node that matches the filter. If no matching node is found the status is failure (MFn::kFailure).',
                                                  'inArgs': ['rootPlug',
                                                             'filter',
                                                             'direction',
                                                             'traversal',
                                                             'level'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'direction': [],
                                                                     'filter': [],
                                                                     'level': [],
                                                                     'rootPlug': ['&'],
                                                                     'traversal': []},
                                                  'types': {'direction': ('MItDependencyGraph',
                                                                          'Direction'),
                                                            'filter': ('MFn',
                                                                       'Type'),
                                                            'level': ('MItDependencyGraph',
                                                                      'Level'),
                                                            'rootPlug': 'MPlug',
                                                            'traversal': ('MItDependencyGraph',
                                                                          'Traversal')}},
                                                 {'argInfo': {'direction': {'doc': 'Primary direction of iteration',
                                                                            'type': ('MItDependencyGraph',
                                                                                     'Direction')},
                                                              'infoObject': {'doc': 'MIteratorType Object which has info about the filter list and the object type, the root will be reset to. ',
                                                                             'type': 'MIteratorType'},
                                                              'level': {'doc': 'Level of detail of the iteration',
                                                                        'type': ('MItDependencyGraph',
                                                                                 'Level')},
                                                              'rootNode': {'doc': 'Root Node of the iteration. This can be null if the root has to be reset to plug. ',
                                                                           'type': 'MObject'},
                                                              'rootPlug': {'doc': 'Root plug of the iteration. This can be null if the root has to be reset to node. ',
                                                                           'type': 'MPlug'},
                                                              'traversal': {'doc': 'Order of traversal',
                                                                            'type': ('MItDependencyGraph',
                                                                                     'Traversal')}},
                                                  'args': [('rootNode',
                                                            'MObject',
                                                            'in'),
                                                           ('rootPlug',
                                                            'MPlug',
                                                            'in'),
                                                           ('infoObject',
                                                            'MIteratorType',
                                                            'in'),
                                                           ('direction',
                                                            ('MItDependencyGraph',
                                                             'Direction'),
                                                            'in'),
                                                           ('traversal',
                                                            ('MItDependencyGraph',
                                                             'Traversal'),
                                                            'in'),
                                                           ('level',
                                                            ('MItDependencyGraph',
                                                             'Level'),
                                                            'in')],
                                                  'defaults': {'direction': ('MItDependencyGraph',
                                                                             'Direction',
                                                                             'kDownstream'),
                                                               'level': ('MItDependencyGraph',
                                                                         'Level',
                                                                         'kPlugLevel'),
                                                               'traversal': ('MItDependencyGraph',
                                                                             'Traversal',
                                                                             'kDepthFirst')},
                                                  'deprecated': False,
                                                  'doc': "\r\nClears iterator data and re-initializes the iterator. The filter list is reset to the new list specified thro'  MIteratorType  object. If a valid filter is enabled, the iterator automatically advances to the next node after the root node/plug that matches the filter. If no matching node is found the status is failure (MFn::kFailure).",
                                                  'inArgs': ['rootNode',
                                                             'rootPlug',
                                                             'infoObject',
                                                             'direction',
                                                             'traversal',
                                                             'level'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'direction': [],
                                                                     'infoObject': ['&'],
                                                                     'level': [],
                                                                     'rootNode': ['*'],
                                                                     'rootPlug': ['*'],
                                                                     'traversal': []},
                                                  'types': {'direction': ('MItDependencyGraph',
                                                                          'Direction'),
                                                            'infoObject': 'MIteratorType',
                                                            'level': ('MItDependencyGraph',
                                                                      'Level'),
                                                            'rootNode': 'MObject',
                                                            'rootPlug': 'MPlug',
                                                            'traversal': ('MItDependencyGraph',
                                                                          'Traversal')}}],
                                     'rootNode': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the root node of the iteration.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The root node',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                     'rootPlug': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the root plug of the iteration.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The root plug',
                                                                  'qualifiers': [],
                                                                  'type': 'MPlug'},
                                                   'returnType': 'MPlug',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                     'setCurrentFilter': [{'argInfo': {'filter': {'doc': 'node or Attribute type filter (see MFn::Type)',
                                                                                  'type': ('MFn',
                                                                                           'Type')}},
                                                           'args': [('filter',
                                                                     ('MFn',
                                                                      'Type'),
                                                                     'in')],
                                                           'defaults': {'filter': ('MFn',
                                                                                   'Type',
                                                                                   'kInvalid')},
                                                           'deprecated': False,
                                                           'doc': '\r\nSets the node or plug filter. Plug filtering is based on the type of the corresponding Attribute. Defaults to disabled ( MFn::kInvalid ). If a valid filter is specified, the iterator automatically advances to the next node that matches the filter. If no matching node status is failure (MFn::kFailure).',
                                                           'inArgs': ['filter'],
                                                           'inverse': ('currentFilter',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'filter': []},
                                                           'types': {'filter': ('MFn',
                                                                                'Type')}}],
                                     'setTraversalOverWorldSpaceDependents': [{'argInfo': {'val': {'doc': 'True to enable traversal of world-space dependencies, false to disable.',
                                                                                                   'type': 'bool'}},
                                                                               'args': [('val',
                                                                                         'bool',
                                                                                         'in')],
                                                                               'defaults': {},
                                                                               'deprecated': False,
                                                                               'doc': '\r\nThis method controls whether the iterator will include world-space attribute dependencies in its traversal. For example, say there is an animation curve attached to the translateX attribute on a transform, and an upstream iterator starts at the worldMatrix attribute. If world-space traversal is enabled, the iterator will get to the animation curve. Note however that even when world-space traversal is enabled, the iterator will only iterate to connected nodes. It does not iterate up and down through the dag hierarchy.',
                                                                               'inArgs': ['val'],
                                                                               'outArgs': [],
                                                                               'returnInfo': {'doc': '',
                                                                                              'qualifiers': [],
                                                                                              'type': None},
                                                                               'returnType': None,
                                                                               'static': False,
                                                                               'typeQualifiers': {'val': []},
                                                                               'types': {'val': 'bool'}}],
                                     'thisNode': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': True,
                                                   'doc': '\n This method is obsolete. \n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Current node',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                     'thisNodeHasUnknownType': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nIndicates whether or not the current node has an unrecognised type. This is useful if an unexpected failure is encountered in the  next()  or  thisNode()  methods.',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': ' true Unknown type  false Type is known or iterator is done or failure encountered  ',
                                                                                'qualifiers': [],
                                                                                'type': 'bool'},
                                                                 'returnType': 'bool',
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                                 'types': {}}],
                                     'thisPlug': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the current plug of the iteration. Results in a null plug on failure.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Current plug',
                                                                  'qualifiers': [],
                                                                  'type': 'MPlug'},
                                                   'returnType': 'MPlug',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                     'toggleDirection': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nToggles the direction of the iteration. Resets the root of the iteration to the current node or plug depending on the level of iteration. Clears iterator path data. If a valid filter is enabled, the iterator automatically advances to the next node that matches the filter. If no matching node is found the status is failure (MFn::kFailure). No other iterator parameters are affected.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                     'toggleLevel': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nToggles the level of the iteration. Resets the root of the iteration to the current node or plug depending on the level of iteration. Clears iterator path data. If a valid filter is enabled, the iterator automatically advances to the next node that matches the filter. If no matching node is found the status is failure (MFn::kFailure). No other iterator parameters are affected.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                     'toggleTraversal': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nToggles the traversal of the iteration. Resets the root of the iteration to the current node or plug depending on the level of iteration. Clears iterator path data. If a valid filter is enabled, the iterator automatically advances to the next node that matches the filter. If no matching node is found the status is failure (MFn::kFailure). No other iterator parameters are affected.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}]},
                         'pymelEnums': {'Direction': "Enum('Direction', [('downstream', 0), ('kDownstream', 0), ('upstream', 1), ('kUpstream', 1)], multiKeys=True)",
                                        'Level': "Enum('Level', [('nodeLevel', 0), ('kNodeLevel', 0), ('plugLevel', 1), ('kPlugLevel', 1)], multiKeys=True)",
                                        'Traversal': "Enum('Traversal', [('depthFirst', 0), ('kDepthFirst', 0), ('breadthFirst', 1), ('kBreadthFirst', 1)], multiKeys=True)"},
                         'pymelMethods': {'currentFilter': 'getCurrentFilter'}},
  'MItDependencyNodes': {'enums': {},
                         'methods': {'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'isDone': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nIndicates end of the iteration.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Bool: true if the iteration is done, false otherwise',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                     'item': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': True,
                                               'doc': '\n This method is obsolete. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The dependency node. A null MObject indicates failure.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                     'next': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nMoves to the next node matching the filter. If the filter is set to kInvalid, this method advances to the next DG node without doing any filtering.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                     'reset': [{'argInfo': {'filter': {'doc': 'Function set type (MFn::Type)',
                                                                       'type': ('MFn',
                                                                                'Type')}},
                                                'args': [('filter',
                                                          ('MFn',
                                                           'Type'),
                                                          'in')],
                                                'defaults': {'filter': ('MFn',
                                                                        'Type',
                                                                        'kInvalid')},
                                                'deprecated': False,
                                                'doc': '\r\nResets the iterator and reinitializes the filter.',
                                                'inArgs': ['filter'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'filter': []},
                                                'types': {'filter': ('MFn',
                                                                     'Type')}},
                                               {'argInfo': {'infoObject': {'doc': 'MIterator object, which has filter list information.',
                                                                           'type': 'MIteratorType'}},
                                                'args': [('infoObject',
                                                          'MIteratorType',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nResets the iterator and reinitializes the filter list. The filter list is specified through  MIteratorType  object.',
                                                'inArgs': ['infoObject'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'infoObject': ['&']},
                                                'types': {'infoObject': 'MIteratorType'}}],
                                     'thisNode': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nRetrieves the dependency node to which the iterator points.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The dependency node. A null MObject indicates failure.',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}]},
                         'pymelEnums': {}},
  'MItEdits': {'enums': {'Direction': {'valueDocs': {'forward': 'Visit the edits in the order in which they were added.',
                                                     'kForward': 'Visit the edits in the order in which they were added.',
                                                     'kReverse': 'Visit the edits in the reverse order from how they were added.',
                                                     'reverse': 'Visit the edits in the reverse order from how they were added.'},
                                       'values': "Enum('Direction', {'kForward': 0, 'kReverse': 1})"},
                         'EditStatus': {'valueDocs': {'ALL_EDITS': 'Visit all the edits.',
                                                      'SUCCESSFUL_EDITS': 'Visit successful edits only.'},
                                        'values': "Enum('EditStatus', {'SUCCESSFUL_EDITS': 0, 'ALL_EDITS': 1})"}},
               'methods': {'addRemoveAttrEdit': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the current edit if the current edit is an edit for adding or removing an attribute. The method currentEditType can be used to validate whether the current edit is of the appropriate type. An edit for adding or removing an attribute indicates that an attribute has been added or removed since the file was referenced.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The add or remove attribute edit',
                                                                 'qualifiers': [],
                                                                 'type': 'MAddRemoveAttrEdit'},
                                                  'returnType': 'MAddRemoveAttrEdit',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                           'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'connectDisconnectEdit': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nReturns the current edit if the current edit is a connection or disconnection edit. The method currentEditType can be used to validate whether the current edit is a connection or disconnection edit. A connection or disconnection edit indicates that a connection has been made or broken since the file or assembly was referenced.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The connection or disconnection edit.',
                                                                     'qualifiers': [],
                                                                     'type': 'MConnectDisconnectAttrEdit'},
                                                      'returnType': 'MConnectDisconnectAttrEdit',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                           'currentEditString': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the ASCII string related to the current edit',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The ASCII string related to the current edit',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                           'currentEditType': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the enum related to the type of the current edit.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The current reference or assembly edit type or kNullEdit if there is no current edit.',
                                                               'qualifiers': [],
                                                               'type': ('MEdit',
                                                                        'EditType')},
                                                'returnType': ('MEdit',
                                                               'EditType'),
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                           'edit': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\n Parameters: \n \n [out]  ReturnStatus  return status \n \n \n Returns: The current edit. \n Status Codes: \n MS::kSuccess  operation successful  \n MS::kFailure  no current edit or an invalid iterator  \n \n \n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'The current edit.',
                                                    'qualifiers': [],
                                                    'type': 'MEdit'},
                                     'returnType': 'MEdit',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}}],
                           'fcurveEdit': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the current edit if the current edit is an fcurve edit. The method currentEditType can be used to validate whether or not the current edit is an fcurve edit. An fcurve edit is a modification to an animCurve from a reference.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The fcurve edit.',
                                                          'qualifiers': [],
                                                          'type': 'MFcurveEdit'},
                                           'returnType': 'MFcurveEdit',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                           'isDone': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nIndicates end of the iteration.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Bool: true if the iteration is done, false otherwise',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                           'isReverse': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nIndicates whether the edit lists are iterated in reverse order.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Bool: true if the iteration is reversed, false otherwise',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                           'next': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\nMoves to the next edit.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                           'parentingEdit': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the current edit if the current edit is a parenting edit. The method currentEditType can be used to validate whether or not the current edit is a parenting edit. Parenting edits are modifications to the parent or child of an object from a reference or an assembly.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The parenting edit.',
                                                             'qualifiers': [],
                                                             'type': 'MParentingEdit'},
                                              'returnType': 'MParentingEdit',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                           'removeCurrentEdit': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nRemoves the current edit. \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'True if the edit was removed successfully. False if the edit is stored on a nested assembly or reference.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                           'reset': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nResets the iterator',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                           'setAttrEdit': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns the current edit if the current edit is a setAttr edit. The method currentEditType can be used to validate whether or not the current edit is a setAttr edit. A setAttr edit is a modification to a plug value on an object from a reference or assembly.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The setAttr edit.',
                                                           'qualifiers': [],
                                                           'type': 'MSetAttrEdit'},
                                            'returnType': 'MSetAttrEdit',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}]},
               'pymelEnums': {'Direction': "Enum('Direction', [('forward', 0), ('kForward', 0), ('reverse', 1), ('kReverse', 1)], multiKeys=True)",
                              'EditStatus': "Enum('EditStatus', {'SUCCESSFUL_EDITS': 0, 'ALL_EDITS': 1})"}},
  'MItGeometry': {'enums': {},
                  'invertibles': [('setPosition', 'position'),
                                  ('setAllPositions', 'allPositions')],
                  'methods': {'allPositions': [{'argInfo': {'points': {'doc': 'Storage for positions ',
                                                                       'type': 'MPointArray'},
                                                            'space': {'doc': 'The transformation space in which the operation is done',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('points',
                                                          'MPointArray',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the position of all the points/CVs/vertices. This operation is faster than using the iterator to get values one by one, but uses more memory as it requires an array to hold all the values to be returned.',
                                                'inArgs': ['space'],
                                                'inverse': ('setAllPositions',
                                                            False),
                                                'outArgs': ['points'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'points': ['&'],
                                                                   'space': []},
                                                'types': {'points': 'MPointArray',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'component': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': True,
                                             'doc': '\n This method is obsolete. \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The current component in the iteration.',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                              'count': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the number of items in this iteration. This number will always be at least as large as the number of items, however in some cases it may be larger. It is useful if allocating space in an array to hold the results, since it will always be of sufficient size. If the exact number of items is required, use the exactCount method instead. The exactCount method is however significantly slower than this method.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of items that will be iterated',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'currentItem': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method returns the current component in the iteration.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The current component in the iteration.',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                              'exactCount': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the exact number of items in this iteration. This method is significantly slower than the  count()  method, so use if only if the precise number is required.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The number of items that will be iterated',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                              'index': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method returns the index of the current point/CV/vertex component in the iteration.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The index of the current point/CV/vertex.',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'isDone': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns  true  if the iteration is finished, i.e. there are no more components to iterate on.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Bool true if There are no more components to iterate on, false otherwise.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'next': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nAdvance to the next component in the iteration. If the iterator is already at the last component then this method has no effect. Use  isDone  to determine if the iterator is at the last component.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'normal': [{'argInfo': {'space': {'doc': 'The transformation space in which the operation is done ',
                                                                'type': ('MSpace',
                                                                         'Space')}},
                                          'args': [('space',
                                                    ('MSpace', 'Space'),
                                                    'in')],
                                          'defaults': {'space': ('MSpace',
                                                                 'Space',
                                                                 'kObject')},
                                          'deprecated': False,
                                          'doc': '\r\nReturn the normal of the current point/CV/vertex component.',
                                          'inArgs': ['space'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "The current component's normal",
                                                         'qualifiers': [],
                                                         'type': 'MVector'},
                                          'returnType': 'MVector',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'space': []},
                                          'types': {'space': ('MSpace',
                                                              'Space')}}],
                              'position': [{'argInfo': {'space': {'doc': 'The transformation space in which the operation is done ',
                                                                  'type': ('MSpace',
                                                                           'Space')}},
                                            'args': [('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject')},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the position of the current point/CV/vertex component.',
                                            'inArgs': ['space'],
                                            'inverse': ('setPosition',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The current component's position",
                                                           'qualifiers': [],
                                                           'type': 'MPoint'},
                                            'returnType': 'MPoint',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'space': []},
                                            'types': {'space': ('MSpace',
                                                                'Space')}}],
                              'reset': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReset the iterator to the first component.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'setAllPositions': [{'argInfo': {'pt': {'doc': 'An array containing all the positions to be set ',
                                                                      'type': 'MPointArray'},
                                                               'space': {'doc': 'The transformation space in which the operation is done',
                                                                         'type': ('MSpace',
                                                                                  'Space')}},
                                                   'args': [('pt',
                                                             'MPointArray',
                                                             'in'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject')},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the position of all the points/CVs/vertices at once. This operation is faster than using the iterator to set values one by one, but uses more memory as it requires an array to hold all the values to be set.',
                                                   'inArgs': ['pt',
                                                              'space'],
                                                   'inverse': ('allPositions',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'pt': ['const',
                                                                             '&'],
                                                                      'space': []},
                                                   'types': {'pt': 'MPointArray',
                                                             'space': ('MSpace',
                                                                       'Space')}}],
                              'setPosition': [{'argInfo': {'pt': {'doc': 'New position. ',
                                                                  'type': 'MPoint'},
                                                           'space': {'doc': 'The transformation space in which the operation is done.',
                                                                     'type': ('MSpace',
                                                                              'Space')}},
                                               'args': [('pt',
                                                         'MPoint',
                                                         'in'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nSet the position of the current point/CV/vertex.',
                                               'inArgs': ['pt', 'space'],
                                               'inverse': ('position',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'pt': ['const',
                                                                         '&'],
                                                                  'space': []},
                                               'types': {'pt': 'MPoint',
                                                         'space': ('MSpace',
                                                                   'Space')}}],
                              'weight': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturn the weight of the current point/CV/vertex component.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "The current component's weight ",
                                                         'qualifiers': [],
                                                         'type': 'MWeight'},
                                          'returnType': 'MWeight',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'allPositions': 'getAllPositions',
                                   'position': 'getPosition'}},
  'MItInstancer': {'enums': {},
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'instancer': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the current instancer node as an  MObject .',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'See description. ',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'instancerId': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns a unique identifier for the current instancer. Collectively, this id together with the particle id and the path id uniquely identify a "replaced particle".',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'MUintPtrSz'},
                                                'returnType': 'MUintPtrSz',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                               'instancerPath': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the full DAG path to the instancer that generated the current particle instance.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'See description. ',
                                                                 'qualifiers': [],
                                                                 'type': 'MDagPath'},
                                                  'returnType': 'MDagPath',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'isDone': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns  true  if the iteration is finished, i.e. there are no more dag-paths to replaced-particles in the scene.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': ' true There are no more items to iterate over.  false There are more items in the iteration.   ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'matrix': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the transformation matrix represented by the current path. If there is no such path, identity matrix will be returned.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'See description. ',
                                                          'qualifiers': [],
                                                          'type': 'MMatrix'},
                                           'returnType': 'MMatrix',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'next': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nAdvances the iterator to the next replaced-particle dag-path in the scene. Calling  reset() , then repeatedly calling this method until  isDone()  becomes  true  is equivalent to the following loop structure:',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'nextInstancer': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAdvances the iterator to the next instancer in the scene, skipping over any remaining particles associated with the current instancer.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'nextParticle': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdvances the iterator to the next replaced-particle in the scene, skipping over any remaining dag-paths associated with the current replaced-particle.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'particleId': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns a unique identifier for the current particle. Collectively, this id together with the instancer id and the path id uniquely identify a "replaced particle".',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'path': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the replaced-particle dag-path which the iterator is currently pointing to. Each path is to a shape. If the particle is replaced by a shape directly then there will be only one path per particle. If a particle is replaced by a transform with many child shapes then each one of those shapes will have a path. Amongst the paths corresponding to a given particle there may be multiple paths to multiple shapes. If there is no such path, a null path will be returned.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'See description. ',
                                                        'qualifiers': [],
                                                        'type': 'MDagPath'},
                                         'returnType': 'MDagPath',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'pathId': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns a unique identifier for the current path. Collectively, this id together with the instancer id and the particle id uniquely identify a "replaced particle".',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'reset': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nMoves the iterator to the first dag-path to the first replaced-particle in the scene. If none exist, then  isDone()  will be immediately  true .',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                   'pymelEnums': {}},
  'MItKeyframe': {'enums': {'TangentType': {'valueDocs': {'auto': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values.',
                                                          'clamped': 'Same as smooth except when two keys are very close together in which case the tangents between them are treated as linear. This corrects for slippage which is sometimes seen when spline tangents are used on keyframes which are close together.',
                                                          'fast': 'Fast tangent.',
                                                          'fixed': 'Normally, if a key is moved tangent values will be adjusted to maintain their relationships to the surrounding keys (linear, smooth, etc).',
                                                          'flat': 'The tangent is horizontal.',
                                                          'global_': "Use the global tangent settings in Maya's 'Animation Preferences'.",
                                                          'kTangentAuto': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values.',
                                                          'kTangentClamped': 'Same as smooth except when two keys are very close together in which case the tangents between them are treated as linear. This corrects for slippage which is sometimes seen when spline tangents are used on keyframes which are close together.',
                                                          'kTangentFast': 'Fast tangent.',
                                                          'kTangentFixed': 'Normally, if a key is moved tangent values will be adjusted to maintain their relationships to the surrounding keys (linear, smooth, etc).',
                                                          'kTangentFlat': 'The tangent is horizontal.',
                                                          'kTangentGlobal': "Use the global tangent settings in Maya's 'Animation Preferences'.",
                                                          'kTangentLinear': 'For an in tangent this sets it to point directly at the previous key. For an out tangent it points directly to the next key. This is used to create straight lines between keys.',
                                                          'kTangentPlateau': 'Similar to smooth except that minima and maxima between keyframes are flattened, if necessary, to prevent them overshooting their keys.',
                                                          'kTangentSlow': 'Slow tangent.',
                                                          'kTangentSmooth': 'The in and out tangents are colinear and set to provide a smooth transition from the key before to the key after.',
                                                          'kTangentStep': "The key's value is maintained until the next key is reached whereupon it immediately jumps to the new key's value.",
                                                          'kTangentStepNext': 'Upon leaving the keyframe the value immediately jumps to that of the next keyframe and stays there.',
                                                          'linear': 'For an in tangent this sets it to point directly at the previous key. For an out tangent it points directly to the next key. This is used to create straight lines between keys.',
                                                          'plateau': 'Similar to smooth except that minima and maxima between keyframes are flattened, if necessary, to prevent them overshooting their keys.',
                                                          'slow': 'Slow tangent.',
                                                          'smooth': 'The in and out tangents are colinear and set to provide a smooth transition from the key before to the key after.',
                                                          'step': "The key's value is maintained until the next key is reached whereupon it immediately jumps to the new key's value.",
                                                          'stepNext': 'Upon leaving the keyframe the value immediately jumps to that of the next keyframe and stays there.'},
                                            'values': "Enum('TangentType', {'kTangentGlobal': 0, 'kTangentFixed': 1, 'kTangentLinear': 2, 'kTangentFlat': 3, 'kTangentSmooth': 4, 'kTangentStep': 5, 'kTangentSlow': 6, 'kTangentFast': 7, 'kTangentClamped': 8, 'kTangentPlateau': 9, 'kTangentStepNext': 10, 'kTangentAuto': 11})"}},
                  'invertibles': [('setValue', 'value'),
                                  ('setTangentsLocked', 'tangentsLocked'),
                                  ('setTime', 'time'),
                                  ('setOutTangentType', 'outTangentType'),
                                  ('setInTangentType', 'inTangentType')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'getTangentIn': [{'argInfo': {'x': {'doc': 'Delta x of the slope of the tangent ',
                                                                  'type': ('MItKeyframe',
                                                                           'TangentValue')},
                                                            'y': {'doc': 'Delta y of the slope of the tangent',
                                                                  'type': ('MItKeyframe',
                                                                           'TangentValue')}},
                                                'args': [('x',
                                                          ('MItKeyframe',
                                                           'TangentValue'),
                                                          'out'),
                                                         ('y',
                                                          ('MItKeyframe',
                                                           'TangentValue'),
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nDetermines the x,y value of the tangent to the curve entering the current keyframe.',
                                                'inArgs': [],
                                                'outArgs': ['x', 'y'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'x': ['&'],
                                                                   'y': ['&']},
                                                'types': {'x': ('MItKeyframe',
                                                                'TangentValue'),
                                                          'y': ('MItKeyframe',
                                                                'TangentValue')}}],
                              'getTangentOut': [{'argInfo': {'x': {'doc': 'Delta x of the slope of the tangent ',
                                                                   'type': ('MItKeyframe',
                                                                            'TangentValue')},
                                                             'y': {'doc': 'Delta y of the slope of the tangent',
                                                                   'type': ('MItKeyframe',
                                                                            'TangentValue')}},
                                                 'args': [('x',
                                                           ('MItKeyframe',
                                                            'TangentValue'),
                                                           'out'),
                                                          ('y',
                                                           ('MItKeyframe',
                                                            'TangentValue'),
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nDetermines the x,y value of the tangent to the curve leaving the current keyframe.',
                                                 'inArgs': [],
                                                 'outArgs': ['x', 'y'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'x': ['&'],
                                                                    'y': ['&']},
                                                 'types': {'x': ('MItKeyframe',
                                                                 'TangentValue'),
                                                           'y': ('MItKeyframe',
                                                                 'TangentValue')}}],
                              'inTangentType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nDetermines the type of the tangent to the curve entering the current keyframe.',
                                                 'inArgs': [],
                                                 'inverse': ('setInTangentType',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Type of the tangent',
                                                                'qualifiers': [],
                                                                'type': ('MItKeyframe',
                                                                         'TangentType')},
                                                 'returnType': ('MItKeyframe',
                                                                'TangentType'),
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                              'isDone': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\nIndicates that the iterator has moved beyond the last keyframe on the Anim Curve Node to which the iterator is attached. If  isDone()  returns true, attempting to access the curve via the iterator's  time() ,  value()  etc. methods will return an 'index out of range' error.",
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true Done  false Not done  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'next': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nMoves to the next keyframe on the Anim Curve Node to which the iterator is attached. Attempting to move beyond the last keyframe has no effect (and returns success).',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'outTangentType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nDetermines the type of the tangent to the curve leaving the current keyframe.',
                                                  'inArgs': [],
                                                  'inverse': ('setOutTangentType',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Type of the tangent',
                                                                 'qualifiers': [],
                                                                 'type': ('MItKeyframe',
                                                                          'TangentType')},
                                                  'returnType': ('MItKeyframe',
                                                                 'TangentType'),
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                              'reset': [{'argInfo': {'animCurveNode': {'doc': 'New target Node for attachment to iterator',
                                                                       'type': 'MObject'}},
                                         'args': [('animCurveNode',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nDetaches the iterator from the current Anim Curve Node and attaches it to the given Node. Resets to the first keyframe (index = 0).',
                                         'inArgs': ['animCurveNode'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'animCurveNode': ['&']},
                                         'types': {'animCurveNode': 'MObject'}},
                                        {'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nResets the keyframe index to 0 (first keyframe) on the Anim Curve Node to which the iterator is attached.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'setInTangentType': [{'argInfo': {'tangentType': {'doc': 'Type to which the tangent is to be set',
                                                                                'type': ('MItKeyframe',
                                                                                         'TangentType')}},
                                                    'args': [('tangentType',
                                                              ('MItKeyframe',
                                                               'TangentType'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets the type of the tangent to the curve entering the current keyframe.',
                                                    'inArgs': ['tangentType'],
                                                    'inverse': ('inTangentType',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'tangentType': []},
                                                    'types': {'tangentType': ('MItKeyframe',
                                                                              'TangentType')}}],
                              'setOutTangentType': [{'argInfo': {'tangentType': {'doc': 'Type to which the tangent is to be set',
                                                                                 'type': ('MItKeyframe',
                                                                                          'TangentType')}},
                                                     'args': [('tangentType',
                                                               ('MItKeyframe',
                                                                'TangentType'),
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSets the type of the tangent to the curve entering the current keyframe.',
                                                     'inArgs': ['tangentType'],
                                                     'inverse': ('outTangentType',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'tangentType': []},
                                                     'types': {'tangentType': ('MItKeyframe',
                                                                               'TangentType')}}],
                              'setTangentsLocked': [{'argInfo': {'locked': {'doc': 'true if the tangents are to be locked, false otherwise',
                                                                            'type': 'bool'}},
                                                     'args': [('locked',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nLock or unlock the tangents at this keyframe.',
                                                     'inArgs': ['locked'],
                                                     'inverse': ('tangentsLocked',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'locked': []},
                                                     'types': {'locked': 'bool'}}],
                              'setTime': [{'argInfo': {'time': {'doc': 'Time to which the current keyframe time is to be set.',
                                                                'type': 'MTime'}},
                                           'args': [('time',
                                                     'MTime',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSets the time of the current keyframe. This will fail if setting the time would require re-ordering of the keyframes.',
                                           'inArgs': ['time'],
                                           'inverse': ('time', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'time': []},
                                           'types': {'time': 'MTime'}}],
                              'setValue': [{'argInfo': {'value': {'doc': 'Value to which the current keyframe time is to be set.',
                                                                  'type': 'double'}},
                                            'args': [('value',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSets the value of the current keyframe.',
                                            'inArgs': ['value'],
                                            'inverse': ('value', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'value': []},
                                            'types': {'value': 'double'}}],
                              'tangentsLocked': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nDetermines whether the tangents are locked at this keyframe.',
                                                  'inArgs': [],
                                                  'inverse': ('setTangentsLocked',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' true if the tangents are locked  false if the tangents are not locked  ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                              'time': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nDetermines the time of the current keyframe.',
                                        'inArgs': [],
                                        'inverse': ('setTime', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'Time (in seconds) of the current keyframe',
                                                       'qualifiers': [],
                                                       'type': 'MTime'},
                                        'returnType': 'MTime',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                              'value': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nDetermines the value of the current keyframe.',
                                         'inArgs': [],
                                         'inverse': ('setValue', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Value of the current keyframe',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}]},
                  'pymelEnums': {'TangentType': "Enum('TangentType', [('global_', 0), ('kTangentGlobal', 0), ('fixed', 1), ('kTangentFixed', 1), ('linear', 2), ('kTangentLinear', 2), ('flat', 3), ('kTangentFlat', 3), ('smooth', 4), ('kTangentSmooth', 4), ('step', 5), ('kTangentStep', 5), ('slow', 6), ('kTangentSlow', 6), ('fast', 7), ('kTangentFast', 7), ('clamped', 8), ('kTangentClamped', 8), ('plateau', 9), ('kTangentPlateau', 9), ('stepNext', 10), ('kTangentStepNext', 10), ('auto', 11), ('kTangentAuto', 11)], multiKeys=True)"},
                  'pymelMethods': {'inTangentType': 'getInTangentType',
                                   'outTangentType': 'getOutTangentType',
                                   'tangentsLocked': 'getTangentsLocked',
                                   'time': 'getTime',
                                   'value': 'getValue'}},
  'MItMeshEdge': {'enums': {},
                  'invertibles': [('setIndex', 'index'),
                                  ('setPoint', 'point')],
                  'methods': {'center': [{'argInfo': {'space': {'doc': 'The coordinate system for this operation ',
                                                                'type': ('MSpace',
                                                                         'Space')}},
                                          'args': [('space',
                                                    ('MSpace', 'Space'),
                                                    'in')],
                                          'defaults': {'space': ('MSpace',
                                                                 'Space',
                                                                 'kObject')},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the center of the current edge.',
                                          'inArgs': ['space'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The center of the current edge',
                                                         'qualifiers': [],
                                                         'type': 'MPoint'},
                                          'returnType': 'MPoint',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'space': []},
                                          'types': {'space': ('MSpace',
                                                              'Space')}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'cleanupSmoothing': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': True,
                                                    'doc': '\n This method is obsolete. \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                              'connectedToEdge': [{'argInfo': {'index': {'doc': 'Index of edge to check. ',
                                                                         'type': 'int'}},
                                                   'args': [('index',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method determines whether the given edge is connected to the current edge',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Boolean value: true if contained, false otherwise.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': []},
                                                   'types': {'index': 'int'}}],
                              'connectedToFace': [{'argInfo': {'index': {'doc': 'Index of face to check. ',
                                                                         'type': 'int'}},
                                                   'args': [('index',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method determines whether the given face contains the current edge',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Boolean value: true if contained, false otherwise.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': []},
                                                   'types': {'index': 'int'}}],
                              'count': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the number of edges in this iteration.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of edges in the iteration',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'currentItem': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the current edge in the iteration as a component.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The current edge in the interation',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                              'edge': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': '\n This method is obsolete. \n',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The current edge in the interation',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                              'geomChanged': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nReset the geom pointer in the  MItMeshEdge . If you're using  MFnMesh  to update Normals or Color per vertex while iterating, you must call geomChanged on the iterator immediately after the  MFnMesh  call to make sure that your geometry is up to date. A crash may result if this method is not called.",
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'getConnectedEdges': [{'argInfo': {'edges': {'doc': 'Array of edge indices. ',
                                                                           'type': 'MIntArray'}},
                                                     'args': [(u'edges',
                                                               'MIntArray',
                                                               u'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method returns a list of edges connected to the current edge.',
                                                     'inArgs': [],
                                                     'outArgs': [u'edges'],
                                                     'returnInfo': {'doc': 'Number of connected edges',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'edges': ['&']},
                                                     'types': {'edges': 'MIntArray'}}],
                              'getConnectedFaces': [{'argInfo': {'faces': {'doc': 'Array of face indices. ',
                                                                           'type': 'MIntArray'}},
                                                     'args': [(u'faces',
                                                               'MIntArray',
                                                               u'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method returns an array containing the indices of the faces connected to the current edge. Normally a boundary edge will only have one face connected to it and an internal edge will have two, but if the mesh has manifold geometry then the edge may have three or more faces connected to it.',
                                                     'inArgs': [],
                                                     'outArgs': [u'faces'],
                                                     'returnInfo': {'doc': 'Number of connected faces',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'faces': ['&']},
                                                     'types': {'faces': 'MIntArray'}}],
                              'getLength': [{'argInfo': {'length': {'doc': 'length of edge ',
                                                                    'type': 'double',
                                                                    'unitType': u'linear'},
                                                         'space': {'doc': 'Coordinate space in which to perform the operation.',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('length',
                                                       'double',
                                                       'out'),
                                                      ('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nThis method returns the length of the current edge.',
                                             'inArgs': ['space'],
                                             'outArgs': ['length'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'length': ['&'],
                                                                'space': []},
                                             'types': {'length': 'double',
                                                       'space': ('MSpace',
                                                                 'Space')}}],
                              'index': [{'argInfo': {'index': {'doc': 'The vertex index in current edge (0 or 1) ',
                                                               'type': 'int'}},
                                         'args': [('index', 'int', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method returns a vertex index for the current edge based upon the specified index. The index can be either 0 or 1 since an edge is made up of exactly two vertices.',
                                         'inArgs': ['index'],
                                         'inverse': ('setIndex', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The index in the vertex list of the edge vertex requested',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': []},
                                         'types': {'index': 'int'}},
                                        {'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method returns the index of the current edge in the iteration.',
                                         'inArgs': [],
                                         'inverse': ('setIndex', False),
                                         'outArgs': [],
                                         'pymelName': 'getIndex',
                                         'returnInfo': {'doc': 'The index of the current edge in the iteration',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'isDone': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nIndicates if all of the edges have been traversed yet.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Boolean value: true All edges have been traversed, false otherwise.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'isSmooth': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method determines if the current edge in the iteration is smooth (soft).',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Boolean value: true if the edge is smooth (soft), false if the edge is hard.',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                              'next': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nAdvance to the next edge in the iteration.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'numConnectedEdges': [{'argInfo': {'edgeCount': {'doc': 'Number of connected edges.',
                                                                               'type': 'int'}},
                                                     'args': [(u'edgeCount',
                                                               'int',
                                                               u'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method returns the number of edges connected to the current edge.',
                                                     'inArgs': [],
                                                     'outArgs': [u'edgeCount'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'edgeCount': ['&']},
                                                     'types': {'edgeCount': 'int'}}],
                              'numConnectedFaces': [{'argInfo': {'faceCount': {'doc': 'Number of connected faces',
                                                                               'type': 'int'}},
                                                     'args': [('faceCount',
                                                               'int',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method returns the number of faces (1 or 2 ) connected to the current edge.',
                                                     'inArgs': [],
                                                     'outArgs': ['faceCount'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'faceCount': ['&']},
                                                     'types': {'faceCount': 'int'}}],
                              'onBoundary': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method checks to see if the current edge is a border edge.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': "Boolean value: true if it's a border edge, false otherwise.",
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                              'point': [{'argInfo': {'index': {'doc': 'The vertex of the edge we wish to examine (0 or 1) ',
                                                               'type': 'int'},
                                                     'space': {'doc': 'The coordinate system for this operation ',
                                                               'type': ('MSpace',
                                                                        'Space')}},
                                         'args': [('index', 'int', 'in'),
                                                  ('space',
                                                   ('MSpace', 'Space'),
                                                   'in')],
                                         'defaults': {'space': ('MSpace',
                                                                'Space',
                                                                'kObject')},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the position of the specified vertex of the current edge.',
                                         'inArgs': ['index', 'space'],
                                         'inverse': ('setPoint', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The position of the edge vertex for the given index',
                                                        'qualifiers': [],
                                                        'type': 'MPoint'},
                                         'returnType': 'MPoint',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'index': [],
                                                            'space': []},
                                         'types': {'index': 'int',
                                                   'space': ('MSpace',
                                                             'Space')}}],
                              'reset': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReset the iterator to the first edge.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}},
                                        {'argInfo': {'component': {'doc': 'The constraint object. May be a vertex, a face or an edge component',
                                                                   'type': 'MObject'},
                                                     'polyObject': {'doc': 'The mesh object for the iteration ',
                                                                    'type': 'MObject'}},
                                         'args': [('polyObject',
                                                   'MObject',
                                                   'in'),
                                                  ('component',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'component': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nReset the iterator to the first edge in the supplied mesh. Uses the edges constrained by the given component. If component is null then the iteration will be for all edges in the given polygon.',
                                         'inArgs': ['polyObject',
                                                    'component'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'component': ['&'],
                                                            'polyObject': ['&']},
                                         'types': {'component': 'MObject',
                                                   'polyObject': 'MObject'}},
                                        {'argInfo': {'component': {'doc': 'The constraint object. May be a vertex, a face or an edge component',
                                                                   'type': 'MObject'},
                                                     'polyObject': {'doc': 'The surface to iterate over ',
                                                                    'type': 'MDagPath'}},
                                         'args': [('polyObject',
                                                   'MDagPath',
                                                   'in'),
                                                  ('component',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {'component': 'MObject::kNullObj'},
                                         'deprecated': False,
                                         'doc': '\r\nReset the iterator to the first edge in the supplied mesh. Uses the edges constrained by the given component. If component is null then the iteration will be for all edges in the given polygon.',
                                         'inArgs': ['polyObject',
                                                    'component'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'component': ['&'],
                                                            'polyObject': ['const',
                                                                           '&']},
                                         'types': {'component': 'MObject',
                                                   'polyObject': 'MDagPath'}}],
                              'setIndex': [{'argInfo': {'index': {'doc': 'The index of desired edge to access. ',
                                                                  'type': 'int'},
                                                        'prevIndex': {'doc': 'Index of the edge which was current before the change.',
                                                                      'type': 'int'}},
                                            'args': [('index',
                                                      'int',
                                                      'in'),
                                                     ('prevIndex',
                                                      'int',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method sets the index of the current edge to be accessed. The current edge will no longer be in sync with any previous iteration.',
                                            'inArgs': ['index'],
                                            'inverse': ('index', True),
                                            'outArgs': ['prevIndex'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'index': [],
                                                               'prevIndex': ['&']},
                                            'types': {'index': 'int',
                                                      'prevIndex': 'int'}}],
                              'setPoint': [{'argInfo': {'index': {'doc': 'The vertex index of the current edge we wish to set (0 or 1) ',
                                                                  'type': 'uint'},
                                                        'point': {'doc': 'The new value for the edge ',
                                                                  'type': 'MPoint'},
                                                        'space': {'doc': 'The coordinate system for this operation',
                                                                  'type': ('MSpace',
                                                                           'Space')}},
                                            'args': [('point',
                                                      'MPoint',
                                                      'in'),
                                                     ('index',
                                                      'uint',
                                                      'in'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject')},
                                            'deprecated': False,
                                            'doc': '\r\nSet the specified vertex of the current edge to the given value.',
                                            'inArgs': ['point',
                                                       'index',
                                                       'space'],
                                            'inverse': ('point', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'index': ['unsigned'],
                                                               'point': ['const',
                                                                         '&'],
                                                               'space': []},
                                            'types': {'index': 'uint',
                                                      'point': 'MPoint',
                                                      'space': ('MSpace',
                                                                'Space')}}],
                              'setSmoothing': [{'argInfo': {'smooth': {'doc': 'if true the edge will be smooth (soft), otherwise the edge will be hard.',
                                                                       'type': 'bool'}},
                                                'args': [('smooth',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'smooth': True},
                                                'deprecated': False,
                                                'doc': '\r\nThis method sets the current edge to be hard or smooth (soft). The  cleanupSmoothing  method is no longer required to be called after setSmoothing in Maya3.0 and later versions.',
                                                'inArgs': ['smooth'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'smooth': []},
                                                'types': {'smooth': 'bool'}}],
                              'updateSurface': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSignal that this polygonal surface has changed and needs to redraw itself.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'index': 'getIndex', 'point': 'getPoint'}},
  'MItMeshFaceVertex': {'enums': {},
                        'methods': {'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'currentItem': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturns the double componet index of the vertex and face.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'An MObject containing the double index.',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                    'faceId': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the current face index.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The index of the current face.',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                    'faceVertId': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the relative index of the vertex within the current face. This index together with the faceId can be used for a fast access to get various info stored per vertex (normals, uvs, colors).',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The relative index of the current vertex.',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                    'faceVertex': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': True,
                                                    'doc': '\n This method is obsolete. \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'An MObject containing the double index.',
                                                                   'qualifiers': [],
                                                                   'type': 'MObject'},
                                                    'returnType': 'MObject',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                    'geomChanged': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReset the geom pointer in the  MItMeshFaceVertex .',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'getBinormal': [{'argInfo': {'space': {'doc': 'The transformation space ',
                                                                           'type': ('MSpace',
                                                                                    'Space')},
                                                                 'uvSet': {'doc': 'The name of the associated UV set. ',
                                                                           'type': 'MString'}},
                                                     'args': [('space',
                                                               ('MSpace',
                                                                'Space'),
                                                               'in'),
                                                              ('uvSet',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {'space': ('MSpace',
                                                                            'Space',
                                                                            'kObject'),
                                                                  'uvSet': None},
                                                     'deprecated': False,
                                                     'doc': '\nReturn the face vertex binormal associated with the UV set.',
                                                     'inArgs': ['space',
                                                                'uvSet'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': "The normalized binormal vector. A null vector will be returned if the tangent can't be found. ",
                                                                    'qualifiers': [],
                                                                    'type': 'MVector'},
                                                     'returnType': 'MVector',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'space': [],
                                                                        'uvSet': ['const',
                                                                                  '*']},
                                                     'types': {'space': ('MSpace',
                                                                         'Space'),
                                                               'uvSet': 'MString'}}],
                                    'getColor': [{'argInfo': {'color': {'doc': 'Current face vertex color ',
                                                                        'type': 'MColor'},
                                                              'colorSetName': {'doc': 'Name of the color set.',
                                                                               'type': 'MString'}},
                                                  'args': [('color',
                                                            'MColor',
                                                            'out'),
                                                           ('colorSetName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {'colorSetName': None},
                                                  'deprecated': False,
                                                  'doc': '\nReturn a color of the current face vertex.',
                                                  'inArgs': ['colorSetName'],
                                                  'outArgs': ['color'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['&'],
                                                                     'colorSetName': ['const',
                                                                                      '*']},
                                                  'types': {'color': 'MColor',
                                                            'colorSetName': 'MString'}}],
                                    'getColorIndex': [{'argInfo': {'colorIndex': {'doc': 'Storage for the color index ',
                                                                                  'type': 'int'},
                                                                   'colorSetName': {'doc': 'Name of the color set.',
                                                                                    'type': 'MString'}},
                                                       'args': [('colorIndex',
                                                                 'int',
                                                                 'out'),
                                                                ('colorSetName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {'colorSetName': None},
                                                       'deprecated': False,
                                                       'doc': '\nReturn a color index of the current face vertex.',
                                                       'inArgs': ['colorSetName'],
                                                       'outArgs': ['colorIndex'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'colorIndex': ['&'],
                                                                          'colorSetName': ['const',
                                                                                           '*']},
                                                       'types': {'colorIndex': 'int',
                                                                 'colorSetName': 'MString'}}],
                                    'getNormal': [{'argInfo': {'normal': {'doc': 'Storage for the normal ',
                                                                          'type': 'MVector'},
                                                               'space': {'doc': 'The transformation space',
                                                                         'type': ('MSpace',
                                                                                  'Space')}},
                                                   'args': [('normal',
                                                             'MVector',
                                                             'out'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject')},
                                                   'deprecated': False,
                                                   'doc': '\nReturn the face vertex normal.',
                                                   'inArgs': ['space'],
                                                   'outArgs': ['normal'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'normal': ['&'],
                                                                      'space': []},
                                                   'types': {'normal': 'MVector',
                                                             'space': ('MSpace',
                                                                       'Space')}}],
                                    'getTangent': [{'argInfo': {'space': {'doc': 'The transformation space. ',
                                                                          'type': ('MSpace',
                                                                                   'Space')},
                                                                'uvSet': {'doc': 'The name of the uv set. ',
                                                                          'type': 'MString'}},
                                                    'args': [('space',
                                                              ('MSpace',
                                                               'Space'),
                                                              'in'),
                                                             ('uvSet',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {'space': ('MSpace',
                                                                           'Space',
                                                                           'kObject'),
                                                                 'uvSet': None},
                                                    'deprecated': False,
                                                    'doc': '\nReturn the face vertex tangent associated with the given UV set. The tangent is defined as the surface tangent of the polygon running in the U direction.',
                                                    'inArgs': ['space',
                                                               'uvSet'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': "The normalized tangent vector. A null vector will be returned if the tangent can't be found. ",
                                                                   'qualifiers': [],
                                                                   'type': 'MVector'},
                                                    'returnType': 'MVector',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'space': [],
                                                                       'uvSet': ['const',
                                                                                 '*']},
                                                    'types': {'space': ('MSpace',
                                                                        'Space'),
                                                              'uvSet': 'MString'}}],
                                    'getUV': [{'argInfo': {'uvPoint': {'doc': 'Storage for u and v values ',
                                                                       'type': 'float2'},
                                                           'uvSet': {'doc': 'UV set to work with',
                                                                     'type': 'MString'}},
                                               'args': [('uvPoint',
                                                         'float2',
                                                         'out'),
                                                        ('uvSet',
                                                         'MString',
                                                         'in')],
                                               'defaults': {'uvSet': None},
                                               'deprecated': False,
                                               'doc': '\nReturn the texture coordinate for the current face vertex.',
                                               'inArgs': ['uvSet'],
                                               'outArgs': ['uvPoint'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'uvPoint': ['&'],
                                                                  'uvSet': ['const',
                                                                            '*']},
                                               'types': {'uvPoint': 'float2',
                                                         'uvSet': 'MString'}}],
                                    'getUVIndex': [{'argInfo': {'index': {'doc': 'Storage for the texture coordinate index of the current face vertex ',
                                                                          'type': 'int'},
                                                                'uvSet': {'doc': 'UV set to work with',
                                                                          'type': 'MString'}},
                                                    'args': [('index',
                                                              'int',
                                                              'out'),
                                                             ('uvSet',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {'uvSet': None},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the index of the texture coordinate for the current face vertex. This index refers to an element of the texture coordinate array for the polygonal object returned by  MFnMesh::getUVs .',
                                                    'inArgs': ['uvSet'],
                                                    'outArgs': ['index'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'index': ['&'],
                                                                       'uvSet': ['const',
                                                                                 '*']},
                                                    'types': {'index': 'int',
                                                              'uvSet': 'MString'}},
                                                   {'argInfo': {'index': {'doc': 'Storage for the texture coordinate index of the specified vertex ',
                                                                          'type': 'int'},
                                                                'u': {'doc': 'Storage for u value ',
                                                                      'type': 'float'},
                                                                'uvSet': {'doc': 'UV set to work with',
                                                                          'type': 'MString'},
                                                                'v': {'doc': 'Storage for v value ',
                                                                      'type': 'float'}},
                                                    'args': [('index',
                                                              'int',
                                                              'out'),
                                                             ('u',
                                                              'float',
                                                              'out'),
                                                             ('v',
                                                              'float',
                                                              'out'),
                                                             ('uvSet',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {'uvSet': None},
                                                    'deprecated': False,
                                                    'doc': '\nReturn the index of the texture coordinate for the current face vertex. This index refers to an element of the texture coordinate array for the polygonal object returned by  MFnMesh::getUVs .',
                                                    'inArgs': ['uvSet'],
                                                    'outArgs': ['index',
                                                                'u',
                                                                'v'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'index': ['&'],
                                                                       'u': ['&'],
                                                                       'uvSet': ['const',
                                                                                 '*'],
                                                                       'v': ['&']},
                                                    'types': {'index': 'int',
                                                              'u': 'float',
                                                              'uvSet': 'MString',
                                                              'v': 'float'}}],
                                    'hasColor': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nThis method determines whether the current face vertex has color-per-vertex set.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Boolean value: true if at least one vertex has color, false otherwise.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'hasUVs': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\nDoes this face vertex has UV's mapped or not.",
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': "Boolean value: true if the face vertex has UV's mapped, false otherwise.",
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}},
                                               {'argInfo': {'uvSet': {'doc': 'UV set to work with ',
                                                                      'type': 'MString'}},
                                                'args': [('uvSet',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\nDoes this face vertex has UV's mapped or not in a given uv set.",
                                                'inArgs': ['uvSet'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': "Boolean value: true if the face vertex has UV's mapped, false otherwise.",
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'uvSet': ['const',
                                                                             '&']},
                                                'types': {'uvSet': 'MString'}}],
                                    'isDone': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nIndicates if all of the face vertices have been traversed.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Boolean value: true All face vertices have been traversed, false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                    'next': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nAdvance to the next face vertext in the iteration.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'normalId': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the normal index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getNormals . These normals are per-polygon per-vertex normals. See the  MFnMesh  description for more information on normals.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The index of the normal for the current vertex',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                    'position': [{'argInfo': {'space': {'doc': 'The coordinate system for this operation ',
                                                                        'type': ('MSpace',
                                                                                 'Space')}},
                                                  'args': [('space',
                                                            ('MSpace',
                                                             'Space'),
                                                            'in')],
                                                  'defaults': {'space': ('MSpace',
                                                                         'Space',
                                                                         'kObject')},
                                                  'deprecated': False,
                                                  'doc': '\nReturn the position of the current face vertex.',
                                                  'inArgs': ['space'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The vertex position',
                                                                 'qualifiers': [],
                                                                 'type': 'MPoint'},
                                                  'returnType': 'MPoint',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'space': []},
                                                  'types': {'space': ('MSpace',
                                                                      'Space')}}],
                                    'reset': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReset the iterator to the first face vertex.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}},
                                              {'argInfo': {'polyObject': {'doc': 'The polygonal object for the iteration',
                                                                          'type': 'MObject'}},
                                               'args': [('polyObject',
                                                         'MObject',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReset the iterator to the first polygon in the supplied surface.',
                                               'inArgs': ['polyObject'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'polyObject': ['const',
                                                                                 '&']},
                                               'types': {'polyObject': 'MObject'}},
                                              {'argInfo': {'component': {'doc': 'The polygons of the polyObject to iterate over',
                                                                         'type': 'MObject'},
                                                           'polyObject': {'doc': 'The surface to iterate over ',
                                                                          'type': 'MDagPath'}},
                                               'args': [('polyObject',
                                                         'MDagPath',
                                                         'in'),
                                                        ('component',
                                                         'MObject',
                                                         'in')],
                                               'defaults': {'component': 'MObject::kNullObj'},
                                               'deprecated': False,
                                               'doc': '\nReset the iterator with the given surface and component. If component is null then the iteration will be for all face vertices in the given surface.',
                                               'inArgs': ['polyObject',
                                                          'component'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'component': ['&'],
                                                                  'polyObject': ['const',
                                                                                 '&']},
                                               'types': {'component': 'MObject',
                                                         'polyObject': 'MDagPath'}}],
                                    'setIndex': [{'argInfo': {'faceIndex': {'doc': 'Index of desired face to access. ',
                                                                            'type': 'int'},
                                                              'faceVertIndex': {'doc': 'Face-relative index of desired vertex to access. ',
                                                                                'type': 'int'},
                                                              'prevFaceId': {'doc': 'Index of the face which was current before the change. ',
                                                                             'type': 'int'},
                                                              'prevVertId': {'doc': 'Face-relative index of the vertex which was current before the change.',
                                                                             'type': 'int'}},
                                                  'args': [('faceIndex',
                                                            'int',
                                                            'in'),
                                                           ('faceVertIndex',
                                                            'int',
                                                            'in'),
                                                           ('prevFaceId',
                                                            'int',
                                                            'out'),
                                                           ('prevVertId',
                                                            'int',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nThis method sets the index of the current face vertex to be accessed. The current face vertex will no longer be in sync with any previous iteration.',
                                                  'inArgs': ['faceIndex',
                                                             'faceVertIndex'],
                                                  'outArgs': ['prevFaceId',
                                                              'prevVertId'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'faceIndex': [],
                                                                     'faceVertIndex': [],
                                                                     'prevFaceId': ['&'],
                                                                     'prevVertId': ['&']},
                                                  'types': {'faceIndex': 'int',
                                                            'faceVertIndex': 'int',
                                                            'prevFaceId': 'int',
                                                            'prevVertId': 'int'}}],
                                    'tangentId': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the tangent (or binormal) index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getTangents() . These tangent or binormals are per-polygon per-vertex. See the  MFnMesh  description for more information on tangents and binormals.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The index of the tangent for the current vertex',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                    'updateSurface': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSignal that this polygonal surface has changed and needs to redraw itself.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                    'vertId': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the index of the current face vertex.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The index of the current face vertex.',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}]},
                        'pymelEnums': {}},
  'MItMeshPolygon': {'enums': {},
                     'invertibles': [('setUV', 'getUV'),
                                     ('setIndex', 'index'),
                                     ('setUVs', 'getUVs'),
                                     ('setPoints', 'getPoints'),
                                     ('setPoint', 'point')],
                     'methods': {'center': [{'argInfo': {'space': {'doc': 'The coordinate system for this operation ',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the position of the center of the current polygon.',
                                             'inArgs': ['space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The center of the current polygon',
                                                            'qualifiers': [],
                                                            'type': 'MPoint'},
                                             'returnType': 'MPoint',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'space': []},
                                             'types': {'space': ('MSpace',
                                                                 'Space')}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'count': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the number of polygons in the iteration.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The number of polygons in the iteration',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                 'currentItem': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the current polygon in the iteration as a component.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The current polygon in the iteration',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'geomChanged': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReset the geom pointer in the  MItMeshPolygon . This is now being handled automatically inside the iterator, and users should no longer need to call this method directly to sync up the iterator to changes made by  MFnMesh',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                 'getArea': [{'argInfo': {'area': {'doc': 'The area ',
                                                                   'type': 'double'},
                                                          'space': {'doc': 'World Space or Object Space',
                                                                    'type': ('MSpace',
                                                                             'Space')}},
                                              'args': [('area',
                                                        'double',
                                                        'out'),
                                                       ('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': '\r\nThis method gets the area of the face',
                                              'inArgs': ['space'],
                                              'outArgs': ['area'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'area': ['&'],
                                                                 'space': []},
                                              'types': {'area': 'double',
                                                        'space': ('MSpace',
                                                                  'Space')}}],
                                 'getAxisAtUV': [{'argInfo': {'normal': {'doc': 'normal for the point ',
                                                                         'type': 'MVector'},
                                                              'space': {'doc': 'The coordinate system for this operation ',
                                                                        'type': ('MSpace',
                                                                                 'Space')},
                                                              'tolerance': {'doc': 'tolerance value to compare float data type',
                                                                            'type': 'float'},
                                                              'uTangent': {'doc': 'u tangent for the point ',
                                                                           'type': 'MVector'},
                                                              'uvPoint': {'doc': 'The UV value to try to locate ',
                                                                          'type': 'float2'},
                                                              'uvSet': {'doc': 'UV set to work with ',
                                                                        'type': 'MString'},
                                                              'vTangent': {'doc': 'v tangent for the point ',
                                                                           'type': 'MVector'}},
                                                  'args': [('normal',
                                                            'MVector',
                                                            'out'),
                                                           ('uTangent',
                                                            'MVector',
                                                            'out'),
                                                           ('vTangent',
                                                            'MVector',
                                                            'out'),
                                                           ('uvPoint',
                                                            'float2',
                                                            'in'),
                                                           ('space',
                                                            ('MSpace',
                                                             'Space'),
                                                            'in'),
                                                           ('uvSet',
                                                            'MString',
                                                            'in'),
                                                           ('tolerance',
                                                            'float',
                                                            'in')],
                                                  'defaults': {'space': ('MSpace',
                                                                         'Space',
                                                                         'kObject'),
                                                               'tolerance': 0.0,
                                                               'uvSet': None},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the axis of the point at the given UV value in the current polygon.',
                                                  'inArgs': ['uvPoint',
                                                             'space',
                                                             'uvSet',
                                                             'tolerance'],
                                                  'outArgs': ['normal',
                                                              'uTangent',
                                                              'vTangent'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'normal': ['&'],
                                                                     'space': [],
                                                                     'tolerance': [],
                                                                     'uTangent': ['&'],
                                                                     'uvPoint': ['&'],
                                                                     'uvSet': ['const',
                                                                               '*'],
                                                                     'vTangent': ['&']},
                                                  'types': {'normal': 'MVector',
                                                            'space': ('MSpace',
                                                                      'Space'),
                                                            'tolerance': 'float',
                                                            'uTangent': 'MVector',
                                                            'uvPoint': 'float2',
                                                            'uvSet': 'MString',
                                                            'vTangent': 'MVector'}}],
                                 'getColor': [{'argInfo': {'color': {'doc': 'The average color ',
                                                                     'type': 'MColor'},
                                                           'colorSetName': {'doc': 'Name of the color set.',
                                                                            'type': 'MString'}},
                                               'args': [('color',
                                                         'MColor',
                                                         'out'),
                                                        ('colorSetName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {'colorSetName': None},
                                               'deprecated': False,
                                               'doc': '\r\nThis method gets the average color of the all the vertices in this face',
                                               'inArgs': ['colorSetName'],
                                               'outArgs': ['color'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'color': ['&'],
                                                                  'colorSetName': ['const',
                                                                                   '*']},
                                               'types': {'color': 'MColor',
                                                         'colorSetName': 'MString'}},
                                              {'argInfo': {'color': {'doc': 'The color to get ',
                                                                     'type': 'MColor'},
                                                           'index': {'doc': 'The face-relative vertex index on this face',
                                                                     'type': 'int'}},
                                               'args': [('color',
                                                         'MColor',
                                                         'out'),
                                                        ('index',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method gets the color of the specified vertex in this face',
                                               'inArgs': ['index'],
                                               'outArgs': ['color'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'color': ['&'],
                                                                  'index': []},
                                               'types': {'color': 'MColor',
                                                         'index': 'int'}}],
                                 'getColorIndex': [{'argInfo': {'colorIndex': {'doc': 'Color index filled in this function. ',
                                                                               'type': 'int'},
                                                                'colorSetName': {'doc': 'Name of the color set.',
                                                                                 'type': 'MString'},
                                                                'vertexIndex': {'doc': 'Face-relative index of vertex. ',
                                                                                'type': 'int'}},
                                                    'args': [('vertexIndex',
                                                              'int',
                                                              'in'),
                                                             ('colorIndex',
                                                              'int',
                                                              'out'),
                                                             ('colorSetName',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {'colorSetName': None},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis method returns the colorIndex for a vertex of the current face.',
                                                    'inArgs': ['vertexIndex',
                                                               'colorSetName'],
                                                    'outArgs': ['colorIndex'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'colorIndex': ['&'],
                                                                       'colorSetName': ['const',
                                                                                        '*'],
                                                                       'vertexIndex': []},
                                                    'types': {'colorIndex': 'int',
                                                              'colorSetName': 'MString',
                                                              'vertexIndex': 'int'}}],
                                 'getColorIndices': [{'argInfo': {'colorIndices': {'doc': 'Color index filled in this function. ',
                                                                                   'type': 'MIntArray'},
                                                                  'colorSetName': {'doc': 'Name of the color set.',
                                                                                   'type': 'MString'}},
                                                      'args': [('colorIndices',
                                                                'MIntArray',
                                                                'out'),
                                                               ('colorSetName',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {'colorSetName': None},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method returns the colorIndices for each vertex on the face.',
                                                      'inArgs': ['colorSetName'],
                                                      'outArgs': ['colorIndices'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'colorIndices': ['&'],
                                                                         'colorSetName': ['const',
                                                                                          '*']},
                                                      'types': {'colorIndices': 'MIntArray',
                                                                'colorSetName': 'MString'}}],
                                 'getColors': [{'argInfo': {'colorSetName': {'doc': 'Name of the color set.',
                                                                             'type': 'MString'},
                                                            'colors': {'doc': 'Storage for the colors of the vertice in this face ',
                                                                       'type': 'MColorArray'}},
                                                'args': [('colors',
                                                          'MColorArray',
                                                          'out'),
                                                         ('colorSetName',
                                                          'MString',
                                                          'in')],
                                                'defaults': {'colorSetName': None},
                                                'deprecated': False,
                                                'doc': '\r\nThis method gets the color of the each vertex in the current face.',
                                                'inArgs': ['colorSetName'],
                                                'outArgs': ['colors'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'colorSetName': ['const',
                                                                                    '*'],
                                                                   'colors': ['&']},
                                                'types': {'colorSetName': 'MString',
                                                          'colors': 'MColorArray'}}],
                                 'getConnectedEdges': [{'argInfo': {'edges': {'doc': 'An array to place all the edge indices into',
                                                                              'type': 'MIntArray'}},
                                                        'args': [('edges',
                                                                  'MIntArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method gets the indices of the edges connected to the vertices of the current face, but DOES not include the edges contained in the current face',
                                                        'inArgs': [],
                                                        'outArgs': ['edges'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'edges': ['&']},
                                                        'types': {'edges': 'MIntArray'}}],
                                 'getConnectedFaces': [{'argInfo': {'faces': {'doc': 'An array to place all the face indices into',
                                                                              'type': 'MIntArray'}},
                                                        'args': [('faces',
                                                                  'MIntArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method gets the indices of the faces connected to the current face.',
                                                        'inArgs': [],
                                                        'outArgs': ['faces'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'faces': ['&']},
                                                        'types': {'faces': 'MIntArray'}}],
                                 'getConnectedVertices': [{'argInfo': {'vertices': {'doc': 'An array to stuff all the vertex indices into',
                                                                                    'type': 'MIntArray'}},
                                                           'args': [('vertices',
                                                                     'MIntArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nThis method gets the object-relative indices of the vertices surrounding the vertices of the current face, but does not include the vertices of the current face',
                                                           'inArgs': [],
                                                           'outArgs': ['vertices'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'vertices': ['&']},
                                                           'types': {'vertices': 'MIntArray'}}],
                                 'getEdges': [{'argInfo': {'edges': {'doc': 'An array to place all the edge indices into',
                                                                     'type': 'MIntArray'}},
                                               'args': [('edges',
                                                         'MIntArray',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method gets the indices of the edges contained in the current face.',
                                               'inArgs': [],
                                               'outArgs': ['edges'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'edges': ['&']},
                                               'types': {'edges': 'MIntArray'}}],
                                 'getNormal': [{'argInfo': {'normal': {'doc': 'Storage for the normal ',
                                                                       'type': 'MVector'},
                                                            'space': {'doc': 'The transformation space',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('normal',
                                                          'MVector',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the face normal of the current polygon.',
                                                'inArgs': ['space'],
                                                'outArgs': ['normal'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'normal': ['&'],
                                                                   'space': []},
                                                'types': {'normal': 'MVector',
                                                          'space': ('MSpace',
                                                                    'Space')}},
                                               {'argInfo': {'index': {'doc': 'face-relative vertex index of the vertex whose normal to retrieve ',
                                                                      'type': 'uint'},
                                                            'normal': {'doc': 'Storage for the normal ',
                                                                       'type': 'MVector'},
                                                            'space': {'doc': 'The transformation space',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('index',
                                                          'uint',
                                                          'in'),
                                                         ('normal',
                                                          'MVector',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the vertex-face normal for the vertex in the current polygon.',
                                                'inArgs': ['index',
                                                           'space'],
                                                'outArgs': ['normal'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned'],
                                                                   'normal': ['&'],
                                                                   'space': []},
                                                'types': {'index': 'uint',
                                                          'normal': 'MVector',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                                 'getNormals': [{'argInfo': {'normalArray': {'doc': 'Storage for the normals ',
                                                                             'type': 'MVectorArray'},
                                                             'space': {'doc': 'The transformation space',
                                                                       'type': ('MSpace',
                                                                                'Space')}},
                                                 'args': [('normalArray',
                                                           'MVectorArray',
                                                           'out'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in')],
                                                 'defaults': {'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject')},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the normals for all vertices in the current face',
                                                 'inArgs': ['space'],
                                                 'outArgs': ['normalArray'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'normalArray': ['&'],
                                                                    'space': []},
                                                 'types': {'normalArray': 'MVectorArray',
                                                           'space': ('MSpace',
                                                                     'Space')}}],
                                 'getPointAtUV': [{'argInfo': {'pt': {'doc': 'Space for the point ',
                                                                      'type': 'MPoint'},
                                                               'space': {'doc': 'The coordinate system for this operation ',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'tolerance': {'doc': 'tolerance value to compare float data type',
                                                                             'type': 'float'},
                                                               'uvPoint': {'doc': 'The UV value to try to locate ',
                                                                           'type': 'float2'},
                                                               'uvSet': {'doc': 'UV set to work with ',
                                                                         'type': 'MString'}},
                                                   'args': [('pt',
                                                             'MPoint',
                                                             'out'),
                                                            ('uvPoint',
                                                             'float2',
                                                             'in'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in'),
                                                            ('uvSet',
                                                             'MString',
                                                             'in'),
                                                            ('tolerance',
                                                             'float',
                                                             'in')],
                                                   'defaults': {'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject'),
                                                                'tolerance': 0.0,
                                                                'uvSet': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the position of the point at the given UV value in the current polygon.',
                                                   'inArgs': ['uvPoint',
                                                              'space',
                                                              'uvSet',
                                                              'tolerance'],
                                                   'outArgs': ['pt'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'pt': ['&'],
                                                                      'space': [],
                                                                      'tolerance': [],
                                                                      'uvPoint': ['&'],
                                                                      'uvSet': ['const',
                                                                                '*']},
                                                   'types': {'pt': 'MPoint',
                                                             'space': ('MSpace',
                                                                       'Space'),
                                                             'tolerance': 'float',
                                                             'uvPoint': 'float2',
                                                             'uvSet': 'MString'}}],
                                 'getPoints': [{'argInfo': {'pointArray': {'doc': 'The array where the vertex positions will be stored ',
                                                                           'type': 'MPointArray'},
                                                            'space': {'doc': 'The coordinate system for this operation ',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('pointArray',
                                                          'MPointArray',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nRetrieves the positions of the vertices on the current face/polygon that the iterator is pointing to. Vertex positions will be inserted into the given array and will be indexed using face-relative vertex IDs (ie. ordered from 0 to (vertexCount of the face) - 1), which should not be confused with the vertexIDs of each vertex in relation to the entire mesh object.',
                                                'inArgs': ['space'],
                                                'inverse': ('setPoints',
                                                            False),
                                                'outArgs': ['pointArray'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'pointArray': ['&'],
                                                                   'space': []},
                                                'types': {'pointArray': 'MPointArray',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                                 'getTriangle': [{'argInfo': {'localTriIndex': {'doc': 'Local index of the desired triangle in this face ',
                                                                                'type': 'int'},
                                                              'points': {'doc': 'Storage for all the vertex points ',
                                                                         'type': 'MPointArray'},
                                                              'space': {'doc': 'World Space or Object Space',
                                                                        'type': ('MSpace',
                                                                                 'Space')},
                                                              'vertexList': {'doc': 'Storage for all the vertex indices ',
                                                                             'type': 'MIntArray'}},
                                                  'args': [('localTriIndex',
                                                            'int',
                                                            'in'),
                                                           ('points',
                                                            'MPointArray',
                                                            'out'),
                                                           ('vertexList',
                                                            'MIntArray',
                                                            'out'),
                                                           ('space',
                                                            ('MSpace',
                                                             'Space'),
                                                            'in')],
                                                  'defaults': {'space': ('MSpace',
                                                                         'Space',
                                                                         'kObject')},
                                                  'deprecated': False,
                                                  'doc': "\r\nGet the vertices and vertex positions of the given triangle in the current face's triangulation.",
                                                  'inArgs': ['localTriIndex',
                                                             'space'],
                                                  'outArgs': ['points',
                                                              'vertexList'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'localTriIndex': [],
                                                                     'points': ['&'],
                                                                     'space': [],
                                                                     'vertexList': ['&']},
                                                  'types': {'localTriIndex': 'int',
                                                            'points': 'MPointArray',
                                                            'space': ('MSpace',
                                                                      'Space'),
                                                            'vertexList': 'MIntArray'}}],
                                 'getTriangles': [{'argInfo': {'points': {'doc': 'Storage for all the vertex points ',
                                                                          'type': 'MPointArray'},
                                                               'space': {'doc': 'World Space or Object Space',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'vertexList': {'doc': 'Storage for all the vertex indices ',
                                                                              'type': 'MIntArray'}},
                                                   'args': [('points',
                                                             'MPointArray',
                                                             'out'),
                                                            ('vertexList',
                                                             'MIntArray',
                                                             'out'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject')},
                                                   'deprecated': False,
                                                   'doc': "\r\nGet the vertices and vertex positions of all the triangles in the current face's triangulation.",
                                                   'inArgs': ['space'],
                                                   'outArgs': ['points',
                                                               'vertexList'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'points': ['&'],
                                                                      'space': [],
                                                                      'vertexList': ['&']},
                                                   'types': {'points': 'MPointArray',
                                                             'space': ('MSpace',
                                                                       'Space'),
                                                             'vertexList': 'MIntArray'}}],
                                 'getUV': [{'argInfo': {'uvPoint': {'doc': 'Storage for u and v values ',
                                                                    'type': 'float2'},
                                                        'uvSet': {'doc': 'UV set to work with',
                                                                  'type': 'MString'},
                                                        'vertex': {'doc': 'The face-relative vertex index to get UV for ',
                                                                   'type': 'int'}},
                                            'args': [('vertex',
                                                      'int',
                                                      'in'),
                                                     ('uvPoint',
                                                      'float2',
                                                      'out'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the texture coordinate for the given vertex.',
                                            'inArgs': ['vertex', 'uvSet'],
                                            'inverse': ('setUV', False),
                                            'outArgs': ['uvPoint'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'uvPoint': ['&'],
                                                               'uvSet': ['const',
                                                                         '*'],
                                                               'vertex': []},
                                            'types': {'uvPoint': 'float2',
                                                      'uvSet': 'MString',
                                                      'vertex': 'int'}}],
                                 'getUVArea': [{'argInfo': {'area': {'doc': 'The uv area ',
                                                                     'type': 'double'},
                                                            'uvSet': {'doc': 'UV set to work with',
                                                                      'type': 'MString'}},
                                                'args': [('area',
                                                          'double',
                                                          'out'),
                                                         ('uvSet',
                                                          'MString',
                                                          'in')],
                                                'defaults': {'uvSet': None},
                                                'deprecated': False,
                                                'doc': '\r\nThis method gets the UV area of the face',
                                                'inArgs': ['uvSet'],
                                                'outArgs': ['area'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'area': ['&'],
                                                                   'uvSet': ['const',
                                                                             '*']},
                                                'types': {'area': 'double',
                                                          'uvSet': 'MString'}}],
                                 'getUVAtPoint': [{'argInfo': {'pt': {'doc': 'The point to try to get UV for ',
                                                                      'type': 'MPoint'},
                                                               'space': {'doc': 'The coordinate system for this operation ',
                                                                         'type': ('MSpace',
                                                                                  'Space')},
                                                               'uvPoint': {'doc': 'Storage for the UV value ',
                                                                           'type': 'float2'},
                                                               'uvSet': {'doc': 'UV set to work with',
                                                                         'type': 'MString'}},
                                                   'args': [('pt',
                                                             'MPoint',
                                                             'in'),
                                                            ('uvPoint',
                                                             'float2',
                                                             'out'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in'),
                                                            ('uvSet',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {'space': ('MSpace',
                                                                          'Space',
                                                                          'kObject'),
                                                                'uvSet': None},
                                                   'deprecated': False,
                                                   'doc': '\r\nFind the point closest to the given point in the current polygon, and return the UV value at that point.',
                                                   'inArgs': ['pt',
                                                              'space',
                                                              'uvSet'],
                                                   'outArgs': ['uvPoint'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'pt': ['&'],
                                                                      'space': [],
                                                                      'uvPoint': ['&'],
                                                                      'uvSet': ['const',
                                                                                '*']},
                                                   'types': {'pt': 'MPoint',
                                                             'space': ('MSpace',
                                                                       'Space'),
                                                             'uvPoint': 'float2',
                                                             'uvSet': 'MString'}}],
                                 'getUVIndex': [{'argInfo': {'index': {'doc': 'Storage for the texture coordinate index of the specified vertex ',
                                                                       'type': 'int'},
                                                             'uvSet': {'doc': 'UV set to work with',
                                                                       'type': 'MString'},
                                                             'vertex': {'doc': 'The face-relative vertex index of the current polygon ',
                                                                        'type': 'int'}},
                                                 'args': [('vertex',
                                                           'int',
                                                           'in'),
                                                          ('index',
                                                           'int',
                                                           'out'),
                                                          ('uvSet',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {'uvSet': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the index of the texture coordinate for the given vertex. This index refers to an element of the texture coordinate array for the polygonal object returned by  MFnMesh::getUVs .',
                                                 'inArgs': ['vertex',
                                                            'uvSet'],
                                                 'outArgs': ['index'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'index': ['&'],
                                                                    'uvSet': ['const',
                                                                              '*'],
                                                                    'vertex': []},
                                                 'types': {'index': 'int',
                                                           'uvSet': 'MString',
                                                           'vertex': 'int'}},
                                                {'argInfo': {'index': {'doc': 'Storage for the texture coordinate index of the specified vertex ',
                                                                       'type': 'int'},
                                                             'u': {'doc': 'Storage for u value ',
                                                                   'type': 'float'},
                                                             'uvSet': {'doc': 'UV set to work with',
                                                                       'type': 'MString'},
                                                             'v': {'doc': 'Storage for v value ',
                                                                   'type': 'float'},
                                                             'vertex': {'doc': 'The face-relative vertex index of the current polygon ',
                                                                        'type': 'int'}},
                                                 'args': [('vertex',
                                                           'int',
                                                           'in'),
                                                          ('index',
                                                           'int',
                                                           'out'),
                                                          ('u',
                                                           'float',
                                                           'out'),
                                                          ('v',
                                                           'float',
                                                           'out'),
                                                          ('uvSet',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {'uvSet': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the index of the texture coordinate for the given vertex. This index refers to an element of the texture coordinate array for the polygonal object returned by  MFnMesh::getUVs .',
                                                 'inArgs': ['vertex',
                                                            'uvSet'],
                                                 'outArgs': ['index',
                                                             'u',
                                                             'v'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'index': ['&'],
                                                                    'u': ['&'],
                                                                    'uvSet': ['const',
                                                                              '*'],
                                                                    'v': ['&'],
                                                                    'vertex': []},
                                                 'types': {'index': 'int',
                                                           'u': 'float',
                                                           'uvSet': 'MString',
                                                           'v': 'float',
                                                           'vertex': 'int'}}],
                                 'getUVSetNames': [{'argInfo': {'setNames': {'doc': 'The string array to return the UV sets names in',
                                                                             'type': 'MStringArray'}},
                                                    'args': [('setNames',
                                                              'MStringArray',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis method is used to find the UV set names mapped to the current face.',
                                                    'inArgs': [],
                                                    'outArgs': ['setNames'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'setNames': ['&']},
                                                    'types': {'setNames': 'MStringArray'}}],
                                 'getUVs': [{'argInfo': {'uArray': {'doc': 'Storage for u values ',
                                                                    'type': 'MFloatArray'},
                                                         'uvSet': {'doc': 'UV set to work with',
                                                                   'type': 'MString'},
                                                         'vArray': {'doc': 'Storage for v values ',
                                                                    'type': 'MFloatArray'}},
                                             'args': [('uArray',
                                                       'MFloatArray',
                                                       'out'),
                                                      ('vArray',
                                                       'MFloatArray',
                                                       'out'),
                                                      ('uvSet',
                                                       'MString',
                                                       'in')],
                                             'defaults': {'uvSet': None},
                                             'deprecated': False,
                                             'doc': '\r\nReturn the all the texture coordinates for the vertices of this face (in local vertex order).',
                                             'inArgs': ['uvSet'],
                                             'inverse': ('setUVs', False),
                                             'outArgs': ['uArray',
                                                         'vArray'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'uArray': ['&'],
                                                                'uvSet': ['const',
                                                                          '*'],
                                                                'vArray': ['&']},
                                             'types': {'uArray': 'MFloatArray',
                                                       'uvSet': 'MString',
                                                       'vArray': 'MFloatArray'}}],
                                 'getVertices': [{'argInfo': {'vertices': {'doc': 'An array to place all the vertex indices into',
                                                                           'type': 'MIntArray'}},
                                                  'args': [('vertices',
                                                            'MIntArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method gets the indices of the vertices of the current face',
                                                  'inArgs': [],
                                                  'outArgs': ['vertices'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'vertices': ['&']},
                                                  'types': {'vertices': 'MIntArray'}}],
                                 'hasColor': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method determines whether the current face has color-per-vertex set for any vertex.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if at least one vertex has color, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}},
                                              {'argInfo': {'vertexIndex': {'doc': 'face-relative vertex index to check for color on ',
                                                                           'type': 'int'}},
                                               'args': [('vertexIndex',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method determines whether the current face has color-per-vertex set for the given vertex.',
                                               'inArgs': ['vertexIndex'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if the given vertex has color, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'vertexIndex': []},
                                               'types': {'vertexIndex': 'int'}}],
                                 'hasUVs': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nTests whether this face has UV's mapped or not (either all the vertices for a face should have UV's, or none of them do, so the UV count for a face is either 0, or equal to the number of vertices).",
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': "Boolean value: true if the face has UV's mapped, false otherwise",
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}},
                                            {'argInfo': {'uvSet': {'doc': 'UV set to work with ',
                                                                   'type': 'MString'}},
                                             'args': [('uvSet',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nTests whether this face has UV's mapped or not (either all the vertices for a face should have UV's, or none of them do, so the UV count for a face is either 0, or equal to the number of vertices).",
                                             'inArgs': ['uvSet'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': "Boolean value: true if the face has UV's mapped, false otherwise",
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'uvSet': ['const',
                                                                          '&']},
                                             'types': {'uvSet': 'MString'}}],
                                 'hasValidTriangulation': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': "\r\nThis method checks if the face has a valid triangulation. If it doesn't, then the face was bad geometry: it may gave degenerate points or cross over itself.",
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Boolean value: true the face has a valid triangulation false otherwise.',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                                            'types': {}}],
                                 'index': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the index of the current polygon.',
                                            'inArgs': [],
                                            'inverse': ('setIndex',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The index of the current polygon',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                 'isConnectedToEdge': [{'argInfo': {'index': {'doc': 'Index of the edge to be tested for ',
                                                                              'type': 'int'}},
                                                        'args': [('index',
                                                                  'int',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method determines whether the given edge is connected to a vertex in the current face',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Boolean value: true if connected, false otherwise.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'index': []},
                                                        'types': {'index': 'int'}}],
                                 'isConnectedToFace': [{'argInfo': {'index': {'doc': 'Index of the face to be tested for ',
                                                                              'type': 'int'}},
                                                        'args': [('index',
                                                                  'int',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method determines whether the given face is adjacent to the current face',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'true if connected, false otherwise.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'index': []},
                                                        'types': {'index': 'int'}}],
                                 'isConnectedToVertex': [{'argInfo': {'index': {'doc': 'Index of the vertex to be tested for ',
                                                                                'type': 'int'}},
                                                          'args': [('index',
                                                                    'int',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis method determines whether the given vertex shares an edge with a vertex in the current face.',
                                                          'inArgs': ['index'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Boolean value: true if connected, false otherwise.',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'index': []},
                                                          'types': {'index': 'int'}}],
                                 'isConvex': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method checks if the face is convex.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if the face is convex, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'isDone': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nIndicates if all of the polygons have been traversed yet.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Boolean value: true if all polygons have been traversed, false otherwise.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                 'isHoled': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method checks if the face has any holes.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean value: true the face has one or more holes, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                 'isLamina': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method checks if the face is a lamina (the face is folded over onto itself).',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if the face is a lamina, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'isPlanar': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method checks if the face is planar',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true the face is planar, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'isStarlike': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method checks if the face is starlike. That is, a line from the centre to any vertex lies entirely within the face.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Boolean value: true if the face is starlike, false otherwise.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                 'isUVReversed': [{'argInfo': {'uvSet': {'doc': 'UV set to work with ',
                                                                         'type': 'MString'}},
                                                   'args': [('uvSet',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {'uvSet': None},
                                                   'deprecated': False,
                                                   'doc': "\r\nThis method checks if the winding order of UV's for this face are reversed (clockwise), or not (counter clockwise)",
                                                   'inArgs': ['uvSet'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': "Boolean value: true if the UV's are reversed (clockwise) false if the UV's are not reversed (counter clockwise).",
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'uvSet': ['const',
                                                                                '*']},
                                                   'types': {'uvSet': 'MString'}}],
                                 'next': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nAdvance to the next polygon in the iteration.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                 'normalIndex': [{'argInfo': {'localVertexIndex': {'doc': 'The face-relative index of the vertex to examine for the current polygon ',
                                                                                   'type': 'int'}},
                                                  'args': [('localVertexIndex',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the normal index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getNormals . These normals are per-polygon per-vertex normals. See the  MFnMesh  description for more information on normals.',
                                                  'inArgs': ['localVertexIndex'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The index of the normal for the specified vertex',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'localVertexIndex': []},
                                                  'types': {'localVertexIndex': 'int'}}],
                                 'numColors': [{'argInfo': {'colorCount': {'doc': 'Storage for the color count ',
                                                                           'type': 'int'},
                                                            'colorSetName': {'doc': 'Name of the color set.',
                                                                             'type': 'MString'}},
                                                'args': [('colorCount',
                                                          'int',
                                                          'out'),
                                                         ('colorSetName',
                                                          'MString',
                                                          'in')],
                                                'defaults': {'colorSetName': None},
                                                'deprecated': False,
                                                'doc': '\r\nThis method checks for the number of colors on vertices in this face.',
                                                'inArgs': ['colorSetName'],
                                                'outArgs': ['colorCount'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'colorCount': ['&'],
                                                                   'colorSetName': ['const',
                                                                                    '*']},
                                                'types': {'colorCount': 'int',
                                                          'colorSetName': 'MString'}}],
                                 'numConnectedEdges': [{'argInfo': {'edgeCount': {'doc': 'Storage for the edge count',
                                                                                  'type': 'int'}},
                                                        'args': [('edgeCount',
                                                                  'int',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method checks for the number of connected edges on the vertices of this face',
                                                        'inArgs': [],
                                                        'outArgs': ['edgeCount'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'edgeCount': ['&']},
                                                        'types': {'edgeCount': 'int'}}],
                                 'numConnectedFaces': [{'argInfo': {'faceCount': {'doc': 'Storage for the face count',
                                                                                  'type': 'int'}},
                                                        'args': [('faceCount',
                                                                  'int',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method checks for the number of connected faces',
                                                        'inArgs': [],
                                                        'outArgs': ['faceCount'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'faceCount': ['&']},
                                                        'types': {'faceCount': 'int'}}],
                                 'numTriangles': [{'argInfo': {'triCount': {'doc': 'Storage for the triangle count',
                                                                            'type': 'int'}},
                                                   'args': [('triCount',
                                                             'int',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis Method checks for the number of triangles in this face in the current triangulation',
                                                   'inArgs': [],
                                                   'outArgs': ['triCount'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'triCount': ['&']},
                                                   'types': {'triCount': 'int'}}],
                                 'onBoundary': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method determines whether the current face is on a boundary',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Boolean value: true if on a boundary, false otherwise.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                 'point': [{'argInfo': {'index': {'doc': 'The face-relative index of the vertex in the current polygon ',
                                                                  'type': 'int'},
                                                        'space': {'doc': 'The coordinate system for this operation ',
                                                                  'type': ('MSpace',
                                                                           'Space')}},
                                            'args': [('index',
                                                      'int',
                                                      'in'),
                                                     ('space',
                                                      ('MSpace',
                                                       'Space'),
                                                      'in')],
                                            'defaults': {'space': ('MSpace',
                                                                   'Space',
                                                                   'kObject')},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the position of the vertex at  index  in the current polygon.',
                                            'inArgs': ['index', 'space'],
                                            'inverse': ('setPoint',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The vertex position',
                                                           'qualifiers': [],
                                                           'type': 'MPoint'},
                                            'returnType': 'MPoint',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'index': [],
                                                               'space': []},
                                            'types': {'index': 'int',
                                                      'space': ('MSpace',
                                                                'Space')}}],
                                 'polygon': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': True,
                                              'doc': '\n This method is obsolete. \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The current polygon in the iteration',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                 'polygonVertexCount': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturn the number of vertices for the current polygon.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The number of vertices for the current polygon',
                                                                        'qualifiers': [],
                                                                        'type': 'int'},
                                                         'returnType': 'int',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                 'reset': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReset the iterator to the first polygon.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}},
                                           {'argInfo': {'polyObject': {'doc': 'The polygon for the iteration',
                                                                       'type': 'MObject'}},
                                            'args': [('polyObject',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReset the iterator to the first polygon in the supplied surface.',
                                            'inArgs': ['polyObject'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'polyObject': ['const',
                                                                              '&']},
                                            'types': {'polyObject': 'MObject'}},
                                           {'argInfo': {'component': {'doc': 'The polygons (faces) of the polyObject to iterate over',
                                                                      'type': 'MObject'},
                                                        'polyObject': {'doc': 'The surface (mesh) to iterate over ',
                                                                       'type': 'MDagPath'}},
                                            'args': [('polyObject',
                                                      'MDagPath',
                                                      'in'),
                                                     ('component',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {'component': 'MObject::kNullObj'},
                                            'deprecated': False,
                                            'doc': '\r\nReset the iterator with the given surface and component. If component is null then the iteration will be for all polygons in the given surface.',
                                            'inArgs': ['polyObject',
                                                       'component'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'component': ['&'],
                                                               'polyObject': ['const',
                                                                              '&']},
                                            'types': {'component': 'MObject',
                                                      'polyObject': 'MDagPath'}}],
                                 'setIndex': [{'argInfo': {'index': {'doc': 'The index of desired face to access. ',
                                                                     'type': 'int'},
                                                           'prevIndex': {'doc': 'The index of the current face in the iteration',
                                                                         'type': 'int'}},
                                               'args': [('index',
                                                         'int',
                                                         'in'),
                                                        ('prevIndex',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method sets the index of the current face to be accessed. The current face will no longer be in sync with any previous iteration.',
                                               'inArgs': ['index',
                                                          'prevIndex'],
                                               'inverse': ('index', True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'index': [],
                                                                  'prevIndex': ['&']},
                                               'types': {'index': 'int',
                                                         'prevIndex': 'int'}}],
                                 'setPoint': [{'argInfo': {'index': {'doc': 'The face-relative index of the vertex in the current polygon ',
                                                                     'type': 'uint'},
                                                           'point': {'doc': 'The new position for the vertex ',
                                                                     'type': 'MPoint'},
                                                           'space': {'doc': 'The coordinate system for this operation',
                                                                     'type': ('MSpace',
                                                                              'Space')}},
                                               'args': [('point',
                                                         'MPoint',
                                                         'in'),
                                                        ('index',
                                                         'uint',
                                                         'in'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nSet the vertex at the given index in the current polygon.',
                                               'inArgs': ['point',
                                                          'index',
                                                          'space'],
                                               'inverse': ('point', True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned'],
                                                                  'point': ['const',
                                                                            '&'],
                                                                  'space': []},
                                               'types': {'index': 'uint',
                                                         'point': 'MPoint',
                                                         'space': ('MSpace',
                                                                   'Space')}}],
                                 'setPoints': [{'argInfo': {'pointArray': {'doc': 'The new positions for the vertices. ',
                                                                           'type': 'MPointArray'},
                                                            'space': {'doc': 'The coordinate system for this operation.',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('pointArray',
                                                          'MPointArray',
                                                          'in'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nSets new locations for vertices of the current polygon that the iterator is pointing to.',
                                                'inArgs': ['pointArray',
                                                           'space'],
                                                'inverse': ('getPoints',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'pointArray': ['&'],
                                                                   'space': []},
                                                'types': {'pointArray': 'MPointArray',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                                 'setUV': [{'argInfo': {'uvPoint': {'doc': 'The UV values to set it to ',
                                                                    'type': 'float2'},
                                                        'uvSet': {'doc': 'UV set to work with',
                                                                  'type': 'MString'},
                                                        'vertexId': {'doc': 'face-relative index of the vertex to set UV for. ',
                                                                     'type': 'int'}},
                                            'args': [('vertexId',
                                                      'int',
                                                      'in'),
                                                     ('uvPoint',
                                                      'float2',
                                                      'in'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nModify the UV value for the given vertex in the current face. If the face is not already mapped, this method will fail.',
                                            'inArgs': ['vertexId',
                                                       'uvPoint',
                                                       'uvSet'],
                                            'inverse': ('getUV', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'uvPoint': ['&'],
                                                               'uvSet': ['const',
                                                                         '*'],
                                                               'vertexId': []},
                                            'types': {'uvPoint': 'float2',
                                                      'uvSet': 'MString',
                                                      'vertexId': 'int'}}],
                                 'setUVs': [{'argInfo': {'uArray': {'doc': 'All the U values - in local face order ',
                                                                    'type': 'MFloatArray'},
                                                         'uvSet': {'doc': 'UV set to work with',
                                                                   'type': 'MString'},
                                                         'vArray': {'doc': 'The corresponding V values ',
                                                                    'type': 'MFloatArray'}},
                                             'args': [('uArray',
                                                       'MFloatArray',
                                                       'in'),
                                                      ('vArray',
                                                       'MFloatArray',
                                                       'in'),
                                                      ('uvSet',
                                                       'MString',
                                                       'in')],
                                             'defaults': {'uvSet': None},
                                             'deprecated': False,
                                             'doc': '\r\nModify the UV value for all vertices in the current face. If the face has not already been mapped, this method will fail.',
                                             'inArgs': ['uArray',
                                                        'vArray',
                                                        'uvSet'],
                                             'inverse': ('getUVs', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'uArray': ['&'],
                                                                'uvSet': ['const',
                                                                          '*'],
                                                                'vArray': ['&']},
                                             'types': {'uArray': 'MFloatArray',
                                                       'uvSet': 'MString',
                                                       'vArray': 'MFloatArray'}}],
                                 'tangentIndex': [{'argInfo': {'localVertexIndex': {'doc': 'The face-relative index of the vertex to examine for the current polygon ',
                                                                                    'type': 'int'}},
                                                   'args': [('localVertexIndex',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the tangent (or binormal) index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getTangents . These tangent or binormals are per-polygon per-vertex. See the  MFnMesh  description for more information on tangents and binormals.',
                                                   'inArgs': ['localVertexIndex'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The index of the tangent for the specified vertex',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'localVertexIndex': []},
                                                   'types': {'localVertexIndex': 'int'}}],
                                 'updateSurface': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSignal that this polygonal surface has changed and needs to redraw itself.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                 'vertexIndex': [{'argInfo': {'index': {'doc': 'The face-relative index of the vertex in the polygon ',
                                                                        'type': 'int'}},
                                                  'args': [('index',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the object-relative index of the specified vertex of the current polygon. The index returned may be used to refer to an element in the vertex list returned by  MFnMesh::getPoints .',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The index in the polygon array of the given vertex',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'index': []},
                                                  'types': {'index': 'int'}}],
                                 'zeroArea': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method checks if its a zero area face',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Boolean value: true if the face has zero area, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'zeroUVArea': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method checks if the UV area of the face is zero',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Boolean value: true if the face has zero UV area, false otherwise.',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}},
                                                {'argInfo': {'uvSet': {'doc': 'UV set to work with ',
                                                                       'type': 'MString'}},
                                                 'args': [('uvSet',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method checks if the UV area of the face is zero',
                                                 'inArgs': ['uvSet'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true if the face has zero UV area  false otherwise.  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'uvSet': ['const',
                                                                              '&']},
                                                 'types': {'uvSet': 'MString'}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'index': 'getIndex',
                                      'point': 'getPoint'}},
  'MItMeshVertex': {'enums': {},
                    'invertibles': [('setIndex', 'index'),
                                    ('setUVs', 'getUVs'),
                                    ('setPosition', 'position'),
                                    ('setUV', 'getUV')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'connectedToEdge': [{'argInfo': {'index': {'doc': 'Index of edge to check. ',
                                                                           'type': 'int'}},
                                                     'args': [('index',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method determines whether the given edge contains the current vertex',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Boolean value: true if contained, false otherwise.',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'index': []},
                                                     'types': {'index': 'int'}}],
                                'connectedToFace': [{'argInfo': {'index': {'doc': 'Index of face to check. ',
                                                                           'type': 'int'}},
                                                     'args': [('index',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method determines whether the given face contains the current vertex',
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Boolean value: true if contained, false otherwise.',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                        'index': []},
                                                     'types': {'index': 'int'}}],
                                'count': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the number of vertices in the iteration.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of vertices in the iteration',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                                'currentItem': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the current vertex in the iteration as a component.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The current vertex in the interation',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                'geomChanged': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "\r\nReset the geom pointer in the  MItMeshVertex . If you're using  MFnMesh  to update Normals or Color per vertex while iterating, you must call geomChanged on the iteratior immediately after the  MFnMesh  call to make sure that your geometry is up to date. A crash may result if this method is not called. A similar approach must be taken for updating upstream vertex tweaks with an  MPlug . After the update, call this method.",
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                'getColor': [{'argInfo': {'color': {'doc': 'Color. ',
                                                                    'type': 'MColor'},
                                                          'colorSetName': {'doc': 'Name of the color set.',
                                                                           'type': 'MString'},
                                                          'faceIndex': {'doc': 'The face to get the color for this vertex for ',
                                                                        'type': 'int'}},
                                              'args': [('color',
                                                        'MColor',
                                                        'out'),
                                                       ('faceIndex',
                                                        'int',
                                                        'in'),
                                                       ('colorSetName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {'colorSetName': None},
                                              'deprecated': False,
                                              'doc': '\r\nThis method gets the color of the current vertex in the specified face',
                                              'inArgs': ['faceIndex',
                                                         'colorSetName'],
                                              'outArgs': ['color'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'color': ['&'],
                                                                 'colorSetName': ['const',
                                                                                  '*'],
                                                                 'faceIndex': []},
                                              'types': {'color': 'MColor',
                                                        'colorSetName': 'MString',
                                                        'faceIndex': 'int'}},
                                             {'argInfo': {'color': {'doc': 'The average color ',
                                                                    'type': 'MColor'},
                                                          'colorSetName': {'doc': 'Name of the color set.',
                                                                           'type': 'MString'}},
                                              'args': [('color',
                                                        'MColor',
                                                        'out'),
                                                       ('colorSetName',
                                                        'MString',
                                                        'in')],
                                              'defaults': {'colorSetName': None},
                                              'deprecated': False,
                                              'doc': '\r\nThis method gets the average color of the vertex',
                                              'inArgs': ['colorSetName'],
                                              'outArgs': ['color'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'color': ['&'],
                                                                 'colorSetName': ['const',
                                                                                  '*']},
                                              'types': {'color': 'MColor',
                                                        'colorSetName': 'MString'}}],
                                'getColorIndices': [{'argInfo': {'colorIndices': {'doc': 'Color indices. ',
                                                                                  'type': 'MIntArray'},
                                                                 'colorSetName': {'doc': 'Name of the color set.',
                                                                                  'type': 'MString'}},
                                                     'args': [('colorIndices',
                                                               'MIntArray',
                                                               'out'),
                                                              ('colorSetName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {'colorSetName': None},
                                                     'deprecated': False,
                                                     'doc': '\r\nThis method returns the colorIndices into the color array see  MFnMesh::getColors()  of the current vertex.',
                                                     'inArgs': ['colorSetName'],
                                                     'outArgs': ['colorIndices'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'colorIndices': ['&'],
                                                                        'colorSetName': ['const',
                                                                                         '*']},
                                                     'types': {'colorIndices': 'MIntArray',
                                                               'colorSetName': 'MString'}}],
                                'getColors': [{'argInfo': {'colorSetName': {'doc': 'Name of the color set.',
                                                                            'type': 'MString'},
                                                           'colors': {'doc': 'Colors. ',
                                                                      'type': 'MColorArray'}},
                                               'args': [('colors',
                                                         'MColorArray',
                                                         'out'),
                                                        ('colorSetName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {'colorSetName': None},
                                               'deprecated': False,
                                               'doc': '\r\nThis method gets the colors of the current vertex for each face it belongs to. If no colors are assigned to the vertex at all, the return values will be (-1 -1 -1 1). If some but not all of the vertex/face colors have been explicitly set, the ones that have not been set will be (0, 0, 0, 1).',
                                               'inArgs': ['colorSetName'],
                                               'outArgs': ['colors'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'colorSetName': ['const',
                                                                                   '*'],
                                                                  'colors': ['&']},
                                               'types': {'colorSetName': 'MString',
                                                         'colors': 'MColorArray'}}],
                                'getConnectedEdges': [{'argInfo': {'edges': {'doc': 'Edge indices.',
                                                                             'type': 'MIntArray'}},
                                                       'args': [('edges',
                                                                 'MIntArray',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method gets the indices of the edges connected to the current vertex.',
                                                       'inArgs': [],
                                                       'outArgs': ['edges'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'edges': ['&']},
                                                       'types': {'edges': 'MIntArray'}}],
                                'getConnectedFaces': [{'argInfo': {'faces': {'doc': 'Face indices.',
                                                                             'type': 'MIntArray'}},
                                                       'args': [('faces',
                                                                 'MIntArray',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method gets the indices of the faces connected to the current vertex.',
                                                       'inArgs': [],
                                                       'outArgs': ['faces'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'faces': ['&']},
                                                       'types': {'faces': 'MIntArray'}}],
                                'getConnectedVertices': [{'argInfo': {'vertices': {'doc': 'Indices of connected vertices.',
                                                                                   'type': 'MIntArray'}},
                                                          'args': [('vertices',
                                                                    'MIntArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis method gets the indices of the vertices surrounding the current vertex',
                                                          'inArgs': [],
                                                          'outArgs': ['vertices'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'vertices': ['&']},
                                                          'types': {'vertices': 'MIntArray'}}],
                                'getNormal': [{'argInfo': {'space': {'doc': 'The transformation space.',
                                                                     'type': ('MSpace',
                                                                              'Space')},
                                                           'vector': {'doc': 'The normal. ',
                                                                      'type': 'MVector'}},
                                               'args': [('vector',
                                                         'MVector',
                                                         'out'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the normal or averaged normal if unshared of the current vertex.',
                                               'inArgs': ['space'],
                                               'outArgs': ['vector'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'space': [],
                                                                  'vector': ['&']},
                                               'types': {'space': ('MSpace',
                                                                   'Space'),
                                                         'vector': 'MVector'}},
                                              {'argInfo': {'faceIndex': {'doc': 'face index to get normal for ',
                                                                         'type': 'int'},
                                                           'space': {'doc': 'The transformation space',
                                                                     'type': ('MSpace',
                                                                              'Space')},
                                                           'vector': {'doc': 'The normal. ',
                                                                      'type': 'MVector'}},
                                               'args': [('vector',
                                                         'MVector',
                                                         'out'),
                                                        ('faceIndex',
                                                         'int',
                                                         'in'),
                                                        ('space',
                                                         ('MSpace',
                                                          'Space'),
                                                         'in')],
                                               'defaults': {'space': ('MSpace',
                                                                      'Space',
                                                                      'kObject')},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the normal of the current vertex in the specified face',
                                               'inArgs': ['faceIndex',
                                                          'space'],
                                               'outArgs': ['vector'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'faceIndex': [],
                                                                  'space': [],
                                                                  'vector': ['&']},
                                               'types': {'faceIndex': 'int',
                                                         'space': ('MSpace',
                                                                   'Space'),
                                                         'vector': 'MVector'}}],
                                'getNormalIndices': [{'argInfo': {'normalIndices': {'doc': 'The normal indices.',
                                                                                    'type': 'MIntArray'}},
                                                      'args': [('normalIndices',
                                                                'MIntArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method returns the normal indices of the face/vertex associated with the current vertex.',
                                                      'inArgs': [],
                                                      'outArgs': ['normalIndices'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'normalIndices': ['&']},
                                                      'types': {'normalIndices': 'MIntArray'}}],
                                'getNormals': [{'argInfo': {'normalArray': {'doc': 'The normals. ',
                                                                            'type': 'MVectorArray'},
                                                            'space': {'doc': 'The transformation space.',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('normalArray',
                                                          'MVectorArray',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the normals of the current vertex for all faces',
                                                'inArgs': ['space'],
                                                'outArgs': ['normalArray'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'normalArray': ['&'],
                                                                   'space': []},
                                                'types': {'normalArray': 'MVectorArray',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                                'getOppositeVertex': [{'argInfo': {'edgeId': {'doc': 'The edge to get the other vertex for',
                                                                              'type': 'int'},
                                                                   'vertexId': {'doc': "Id of the given edge's opposite vertex. ",
                                                                                'type': 'int'}},
                                                       'args': [('vertexId',
                                                                 'int',
                                                                 'out'),
                                                                ('edgeId',
                                                                 'int',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis gets the other vertex of the given edge',
                                                       'inArgs': ['edgeId'],
                                                       'outArgs': ['vertexId'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'edgeId': [],
                                                                          'vertexId': ['&']},
                                                       'types': {'edgeId': 'int',
                                                                 'vertexId': 'int'}}],
                                'getUV': [{'argInfo': {'uvPoint': {'doc': 'UV value. ',
                                                                   'type': 'float2'},
                                                       'uvSet': {'doc': 'Name of the uv set to work with.',
                                                                 'type': 'MString'}},
                                           'args': [('uvPoint',
                                                     'float2',
                                                     'out'),
                                                    ('uvSet',
                                                     'MString',
                                                     'in')],
                                           'defaults': {'uvSet': None},
                                           'deprecated': False,
                                           'doc': '\r\nGet the shared UV value at this vertex',
                                           'inArgs': ['uvSet'],
                                           'inverse': ('setUV', False),
                                           'outArgs': ['uvPoint'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'uvPoint': ['&'],
                                                              'uvSet': ['const',
                                                                        '*']},
                                           'types': {'uvPoint': 'float2',
                                                     'uvSet': 'MString'}},
                                          {'argInfo': {'faceId': {'doc': 'Index of the required face ',
                                                                  'type': 'int'},
                                                       'uvPoint': {'doc': 'UV value. ',
                                                                   'type': 'float2'},
                                                       'uvSet': {'doc': 'Name of the uv set to work with',
                                                                 'type': 'MString'}},
                                           'args': [('faceId',
                                                     'int',
                                                     'in'),
                                                    ('uvPoint',
                                                     'float2',
                                                     'out'),
                                                    ('uvSet',
                                                     'MString',
                                                     'in')],
                                           'defaults': {'uvSet': None},
                                           'deprecated': False,
                                           'doc': '\r\nGet the UV value for the give facen at the current vertex',
                                           'inArgs': ['faceId', 'uvSet'],
                                           'inverse': ('setUV', False),
                                           'outArgs': ['uvPoint'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'faceId': [],
                                                              'uvPoint': ['&'],
                                                              'uvSet': ['const',
                                                                        '*']},
                                           'types': {'faceId': 'int',
                                                     'uvPoint': 'float2',
                                                     'uvSet': 'MString'}}],
                                'getUVIndices': [{'argInfo': {'uvIndices': {'doc': 'UV indices. ',
                                                                            'type': 'MIntArray'},
                                                              'uvSet': {'doc': 'Name of the uv set.',
                                                                        'type': 'MString'}},
                                                  'args': [('uvIndices',
                                                            'MIntArray',
                                                            'out'),
                                                           ('uvSet',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {'uvSet': None},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method returns the uv indices into the normal array see  MFnMesh::getUVs()  of the current vertex.',
                                                  'inArgs': ['uvSet'],
                                                  'outArgs': ['uvIndices'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'uvIndices': ['&'],
                                                                     'uvSet': ['const',
                                                                               '*']},
                                                  'types': {'uvIndices': 'MIntArray',
                                                            'uvSet': 'MString'}}],
                                'getUVs': [{'argInfo': {'faceIds': {'doc': 'The corresponding face Ids ',
                                                                    'type': 'MIntArray'},
                                                        'uArray': {'doc': 'U values in local face order. ',
                                                                   'type': 'MFloatArray'},
                                                        'uvSet': {'doc': 'Name of the uv set to work with',
                                                                  'type': 'MString'},
                                                        'vArray': {'doc': 'V values in local face order. ',
                                                                   'type': 'MFloatArray'}},
                                            'args': [('uArray',
                                                      'MFloatArray',
                                                      'out'),
                                                     ('vArray',
                                                      'MFloatArray',
                                                      'out'),
                                                     ('faceIds',
                                                      'MIntArray',
                                                      'out'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nGet the UV values for all mapped faces at the current vertex. If at least one face was mapped the method will succeed.',
                                            'inArgs': ['uvSet'],
                                            'inverse': ('setUVs', False),
                                            'outArgs': ['uArray',
                                                        'vArray',
                                                        'faceIds'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'faceIds': ['&'],
                                                               'uArray': ['&'],
                                                               'uvSet': ['const',
                                                                         '*'],
                                                               'vArray': ['&']},
                                            'types': {'faceIds': 'MIntArray',
                                                      'uArray': 'MFloatArray',
                                                      'uvSet': 'MString',
                                                      'vArray': 'MFloatArray'}}],
                                'hasColor': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method determines whether the current Vertex has a color set for one or more faces.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean value: true if a color is set for at least one face, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}},
                                             {'argInfo': {'index': {'doc': 'Index of face to check. ',
                                                                    'type': 'int'}},
                                              'args': [('index',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method determines whether the given face has a color set for the current vertex.',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean value: true if a color has been set, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'index': []},
                                              'types': {'index': 'int'}}],
                                'index': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the index of the current vertex in the vertex list for this polygonal object. Polygonal objects contain a list of vertices. Faces and edges are specified as indicies from this list, in this way vertices can be shared amoung faces and edges.',
                                           'inArgs': [],
                                           'inverse': ('setIndex', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The index in the vertex list for the current vertex',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                                'isDone': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nIndicates if all of the vertices have been traversed yet.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Boolean value: true if all vertices have been traversed, false otherwise.',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'next': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nAdvance to the next vertex in the iteration.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'numConnectedEdges': [{'argInfo': {'edgeCount': {'doc': 'The number of connected edges.',
                                                                                 'type': 'int'}},
                                                       'args': [('edgeCount',
                                                                 'int',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis Method checks for the number of connected Edges on this vertex',
                                                       'inArgs': [],
                                                       'outArgs': ['edgeCount'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'edgeCount': ['&']},
                                                       'types': {'edgeCount': 'int'}}],
                                'numConnectedFaces': [{'argInfo': {'faceCount': {'doc': 'The number of connected faces.',
                                                                                 'type': 'int'}},
                                                       'args': [('faceCount',
                                                                 'int',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis Method checks for the number of Connected Faces',
                                                       'inArgs': [],
                                                       'outArgs': ['faceCount'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'faceCount': ['&']},
                                                       'types': {'faceCount': 'int'}}],
                                'numUVs': [{'argInfo': {'uvCount': {'doc': 'The UV count ',
                                                                    'type': 'int'},
                                                        'uvSet': {'doc': 'Name of the uv set to work with',
                                                                  'type': 'MString'}},
                                            'args': [('uvCount',
                                                      'int',
                                                      'out'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nThis method returns the number of unique UVs mapped on this vertex',
                                            'inArgs': ['uvSet'],
                                            'outArgs': ['uvCount'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'uvCount': ['&'],
                                                               'uvSet': ['const',
                                                                         '*']},
                                            'types': {'uvCount': 'int',
                                                      'uvSet': 'MString'}}],
                                'onBoundary': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis method determines whether the current vertex is on a Boundary',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Boolean value: true if contained, false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                'position': [{'argInfo': {'space': {'doc': 'The transformation space ',
                                                                    'type': ('MSpace',
                                                                             'Space')}},
                                              'args': [('space',
                                                        ('MSpace',
                                                         'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the position of the current vertex in the specified space. Object space ignores all transformations for the polygon, world space includes all such transformations.',
                                              'inArgs': ['space'],
                                              'inverse': ('setPosition',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The position of the vertex in the specified space',
                                                             'qualifiers': [],
                                                             'type': 'MPoint'},
                                              'returnType': 'MPoint',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'space': []},
                                              'types': {'space': ('MSpace',
                                                                  'Space')}}],
                                'reset': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReset the iterator to the first vertex.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}},
                                          {'argInfo': {'polyObject': {'doc': 'The polygon for the iteration',
                                                                      'type': 'MObject'}},
                                           'args': [('polyObject',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReset the iterator to the first vertex in the supplied polygon.',
                                           'inArgs': ['polyObject'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'polyObject': ['&']},
                                           'types': {'polyObject': 'MObject'}},
                                          {'argInfo': {'component': {'doc': 'The vertices of the polyObject to iterate over',
                                                                     'type': 'MObject'},
                                                       'polyObject': {'doc': 'The surface to iterate over ',
                                                                      'type': 'MDagPath'}},
                                           'args': [('polyObject',
                                                     'MDagPath',
                                                     'in'),
                                                    ('component',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {'component': 'MObject::kNullObj'},
                                           'deprecated': False,
                                           'doc': '\r\nReset the iterator with the given polygon and component. If component is null then the iteration will be for all vertices in the given polygon.',
                                           'inArgs': ['polyObject',
                                                      'component'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'component': ['&'],
                                                              'polyObject': ['const',
                                                                             '&']},
                                           'types': {'component': 'MObject',
                                                     'polyObject': 'MDagPath'}}],
                                'setIndex': [{'argInfo': {'index': {'doc': 'Index of desired vertex to access. ',
                                                                    'type': 'int'},
                                                          'prevIndex': {'doc': 'Index of vertex which was current before the change.',
                                                                        'type': 'int'}},
                                              'args': [('index',
                                                        'int',
                                                        'in'),
                                                       ('prevIndex',
                                                        'int',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method sets the index of the current vertex to be accessed. The current vertex will no longer be in sync with any previous iteration.',
                                              'inArgs': ['index'],
                                              'inverse': ('index', True),
                                              'outArgs': ['prevIndex'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'index': [],
                                                                 'prevIndex': ['&']},
                                              'types': {'index': 'int',
                                                        'prevIndex': 'int'}}],
                                'setPosition': [{'argInfo': {'point': {'doc': 'The new position for the current vertex ',
                                                                       'type': 'MPoint'},
                                                             'space': {'doc': 'Transformation space',
                                                                       'type': ('MSpace',
                                                                                'Space')}},
                                                 'args': [('point',
                                                           'MPoint',
                                                           'in'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in')],
                                                 'defaults': {'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject')},
                                                 'deprecated': False,
                                                 'doc': '\r\nSet the position of the current vertex in the given space.',
                                                 'inArgs': ['point',
                                                            'space'],
                                                 'inverse': ('position',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'point': ['const',
                                                                              '&'],
                                                                    'space': []},
                                                 'types': {'point': 'MPoint',
                                                           'space': ('MSpace',
                                                                     'Space')}}],
                                'setUV': [{'argInfo': {'uvPoint': {'doc': 'The UV value to set. ',
                                                                   'type': 'float2'},
                                                       'uvSet': {'doc': 'Name of the UV set to work with',
                                                                 'type': 'MString'}},
                                           'args': [('uvPoint',
                                                     'float2',
                                                     'in'),
                                                    ('uvSet',
                                                     'MString',
                                                     'in')],
                                           'defaults': {'uvSet': None},
                                           'deprecated': False,
                                           'doc': '\r\nSet the shared UV value at this vertex',
                                           'inArgs': ['uvPoint', 'uvSet'],
                                           'inverse': ('getUV', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'uvPoint': ['&'],
                                                              'uvSet': ['const',
                                                                        '*']},
                                           'types': {'uvPoint': 'float2',
                                                     'uvSet': 'MString'}},
                                          {'argInfo': {'faceId': {'doc': 'Index of required face ',
                                                                  'type': 'int'},
                                                       'uvPoint': {'doc': 'Value of the UV point ',
                                                                   'type': 'float2'},
                                                       'uvSet': {'doc': 'Name of the uv set to work with',
                                                                 'type': 'MString'}},
                                           'args': [('faceId',
                                                     'int',
                                                     'in'),
                                                    ('uvPoint',
                                                     'float2',
                                                     'in'),
                                                    ('uvSet',
                                                     'MString',
                                                     'in')],
                                           'defaults': {'uvSet': None},
                                           'deprecated': False,
                                           'doc': '\r\nSet the UV value for the given face at the current vertex',
                                           'inArgs': ['faceId',
                                                      'uvPoint',
                                                      'uvSet'],
                                           'inverse': ('getUV', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'faceId': [],
                                                              'uvPoint': ['&'],
                                                              'uvSet': ['const',
                                                                        '*']},
                                           'types': {'faceId': 'int',
                                                     'uvPoint': 'float2',
                                                     'uvSet': 'MString'}}],
                                'setUVs': [{'argInfo': {'faceIds': {'doc': 'The corresponding face Ids ',
                                                                    'type': 'MIntArray'},
                                                        'uArray': {'doc': 'All the U values - in local face order ',
                                                                   'type': 'MFloatArray'},
                                                        'uvSet': {'doc': 'Name of the uv set to work with',
                                                                  'type': 'MString'},
                                                        'vArray': {'doc': 'The corresponding V values ',
                                                                   'type': 'MFloatArray'}},
                                            'args': [('uArray',
                                                      'MFloatArray',
                                                      'in'),
                                                     ('vArray',
                                                      'MFloatArray',
                                                      'in'),
                                                     ('faceIds',
                                                      'MIntArray',
                                                      'in'),
                                                     ('uvSet',
                                                      'MString',
                                                      'in')],
                                            'defaults': {'uvSet': None},
                                            'deprecated': False,
                                            'doc': '\r\nSet the UV value for the specified faces at the current vertex. If the face is not already mapped, the value will not be set. If at least ne face was previously mapped, the method should succeed. If no faces were mapped, the method will fail.',
                                            'inArgs': ['uArray',
                                                       'vArray',
                                                       'faceIds',
                                                       'uvSet'],
                                            'inverse': ('getUVs', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'faceIds': ['&'],
                                                               'uArray': ['&'],
                                                               'uvSet': ['const',
                                                                         '*'],
                                                               'vArray': ['&']},
                                            'types': {'faceIds': 'MIntArray',
                                                      'uArray': 'MFloatArray',
                                                      'uvSet': 'MString',
                                                      'vArray': 'MFloatArray'}}],
                                'translateBy': [{'argInfo': {'space': {'doc': 'The transformation space',
                                                                       'type': ('MSpace',
                                                                                'Space')},
                                                             'vector': {'doc': 'The amount of translation ',
                                                                        'type': 'MVector'}},
                                                 'args': [('vector',
                                                           'MVector',
                                                           'in'),
                                                          ('space',
                                                           ('MSpace',
                                                            'Space'),
                                                           'in')],
                                                 'defaults': {'space': ('MSpace',
                                                                        'Space',
                                                                        'kObject')},
                                                 'deprecated': False,
                                                 'doc': '\r\nTranslate the current vertex by the amount specified by the given vector.',
                                                 'inArgs': ['vector',
                                                            'space'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'space': [],
                                                                    'vector': ['const',
                                                                               '&']},
                                                 'types': {'space': ('MSpace',
                                                                     'Space'),
                                                           'vector': 'MVector'}}],
                                'updateSurface': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSignal that this polygonal surface has changed and needs to redraw itself.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                'vertex': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': True,
                                            'doc': '\n This method is obsolete. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The current vertex in the interation',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'index': 'getIndex',
                                     'position': 'getPosition'}},
  'MItSelectionList': {'enums': {'selItemType': {'valueDocs': {'DNselectionItem': 'dependency node',
                                                               'animSelectionItem': 'keyset',
                                                               'dagSelectionItem': 'DAG node or component.',
                                                               'kAnimSelectionItem': 'keyset',
                                                               'kDNselectionItem': 'dependency node',
                                                               'kDagSelectionItem': 'DAG node or component.',
                                                               'kPlugSelectionItem': 'plug',
                                                               'plugSelectionItem': 'plug'},
                                                 'values': "Enum('selItemType', {'kDagSelectionItem': 0, 'kAnimSelectionItem': 1, 'kDNselectionItem': 2, 'kPlugSelectionItem': 3})"}},
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'getDagPath': [{'argInfo': {'component': {'doc': 'A pointer to the selected components of the current selection item.',
                                                                             'type': 'MObject'},
                                                               'dagPath': {'doc': 'The dag path of the current selection item. ',
                                                                           'type': 'MDagPath'}},
                                                   'args': [('dagPath',
                                                             'MDagPath',
                                                             'out'),
                                                            ('component',
                                                             'MObject',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method retrieves the dag path and the components of the current selection item. If components are not selected then NULL is assigned to the component pointer.',
                                                   'inArgs': [],
                                                   'outArgs': ['dagPath',
                                                               'component'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'component': ['&'],
                                                                      'dagPath': ['&']},
                                                   'types': {'component': 'MObject',
                                                             'dagPath': 'MDagPath'}},
                                                  {'argInfo': {'dagPath': {'doc': 'The dag path of the current selection item.',
                                                                           'type': 'MDagPath'}},
                                                   'args': [('dagPath',
                                                             'MDagPath',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method retrieves the dag path of the current selection item.',
                                                   'inArgs': [],
                                                   'outArgs': ['dagPath'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'dagPath': ['&']},
                                                   'types': {'dagPath': 'MDagPath'}}],
                                   'getDependNode': [{'argInfo': {'depNode': {'doc': 'a pointer the the dependency node to be retrieved Returns kNullObj and kFailure if components are selected or selected item does not contain a dependency node.',
                                                                              'type': 'MObject'}},
                                                      'args': [('depNode',
                                                                'MObject',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method retrieves the dependency node of the current selection item',
                                                      'inArgs': [],
                                                      'outArgs': ['depNode'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'depNode': ['&']},
                                                      'types': {'depNode': 'MObject'}}],
                                   'getPlug': [{'argInfo': {'plug': {'doc': 'The plug of the current selection item.',
                                                                     'type': 'MPlug'}},
                                                'args': [('plug',
                                                          'MPlug',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nThis method retrieves the plug of the current selection item.',
                                                'inArgs': [],
                                                'outArgs': ['plug'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'plug': ['&']},
                                                'types': {'plug': 'MPlug'}}],
                                   'getStrings': [{'argInfo': {'array': {'doc': 'Storage for the returned array.',
                                                                         'type': 'MStringArray'}},
                                                   'args': [('array',
                                                             'MStringArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the string representation of the current item in the selection list. It is possible that it will require more than one string to represent the item (the item may contain groups of CVs for example), so a string array is used to pass back the results.',
                                                   'inArgs': [],
                                                   'outArgs': ['array'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'array': ['&']},
                                                   'types': {'array': 'MStringArray'}}],
                                   'hasComponents': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns whether or not the current selection item has components.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': ' true the current selection item has components  false the current selection item does not have components  ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                   'isDone': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nSpecifies whether or not there is anything more to iterator over.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': ' true if there is nothing else to iterate over  false if there are more items left to iterate over  ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                   'itemType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the current selection item type.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' kDagSelectionItem - selection item is in the DAG  kAnimSelectionItem - selection item is a keyset  kDNselectionItem - selection item is a dependency node  ',
                                                                'qualifiers': [],
                                                                'type': ('MItSelectionList',
                                                                         'selItemType')},
                                                 'returnType': ('MItSelectionList',
                                                                'selItemType'),
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                   'next': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nAdvance to the next item. If components are selected then advance to next component.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                   'reset': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReset the iterator. If a filter has been specified then the current item will be the first selected item that matches the filter.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                   'setFilter': [{'argInfo': {'filter': {'doc': 'The MFn::Type that you will be included in the iteration. See MFn.h for possible types.',
                                                                         'type': ('MFn',
                                                                                  'Type')}},
                                                  'args': [('filter',
                                                            ('MFn',
                                                             'Type'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nApply a filter to the iteration. Selection items not matching the filter type will be excluded from the iteration.',
                                                  'inArgs': ['filter'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'filter': []},
                                                  'types': {'filter': ('MFn',
                                                                       'Type')}}]},
                       'pymelEnums': {'selItemType': "Enum('selItemType', [('dagSelectionItem', 0), ('kDagSelectionItem', 0), ('animSelectionItem', 1), ('kAnimSelectionItem', 1), ('DNselectionItem', 2), ('kDNselectionItem', 2), ('plugSelectionItem', 3), ('kPlugSelectionItem', 3)], multiKeys=True)"}},
  'MItSubdEdge': {'enums': {},
                  'invertibles': [('setLevel', 'level')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'index': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the index of the current edge in the edge list for this subdiv object.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The index in the edge list for the current edge',
                                                        'qualifiers': [],
                                                        'type': 'MUint64'},
                                         'returnType': 'MUint64',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'isBoundary': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nChecks if the edge is a boundary.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean indicating whether the edge is boundary or not.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                              'isDone': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nIndicates if all of the edges have been traversed yet.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true All vertices have been traversed  false There are more vertices in the iteration  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'isSharp': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns true if the edge is sharp.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'boolean indicating whether the edge is sharp or not.',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                              'isValid': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nChecks if the iterator is valid.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'bool Boolean to indicate whether the iterator is valid or not.',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                              'level': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the level of the subdiv object.',
                                         'inArgs': [],
                                         'inverse': ('setLevel', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The level.',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'next': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nAdvance to the next edge in the iteration.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'reset': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReset the iterator to the first edge.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'setLevel': [{'argInfo': {'level': {'doc': 'Level of the subdiv ',
                                                                  'type': 'int'}},
                                            'args': [('level',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSets the level of the subdiv object',
                                            'inArgs': ['level'],
                                            'inverse': ('level', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'level': []},
                                            'types': {'level': 'int'}}],
                              'setSharpness': [{'argInfo': {'sharp': {'doc': 'Boolean to mark the edge as sharp or not ',
                                                                      'type': 'bool'}},
                                                'args': [('sharp',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nMarks the edge as sharp.',
                                                'inArgs': ['sharp'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'sharp': []},
                                                'types': {'sharp': 'bool'}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'level': 'getLevel'}},
  'MItSubdFace': {'enums': {},
                  'invertibles': [('setLevel', 'level')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'index': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the index of the current face for this subdiv object.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The index in the face list for the current face',
                                                        'qualifiers': [],
                                                        'type': 'MUint64'},
                                         'returnType': 'MUint64',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'isDone': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nIndicates if all of the faces have been traversed yet.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true All vertices have been traversed  false There are more vertices in the iteration  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                              'isValid': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nChecks if the iterator is valid.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'bool Boolean to indicate whether the iterator is valid or not.',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                              'level': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the level of the subdiv object.',
                                         'inArgs': [],
                                         'inverse': ('setLevel', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The level.',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                              'next': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nAdvance to the next face in the iteration.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'reset': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReset the iterator to the first face.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'setLevel': [{'argInfo': {'level': {'doc': 'New level. ',
                                                                  'type': 'uint'}},
                                            'args': [('level',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSets the level of the subdiv object',
                                            'inArgs': ['level'],
                                            'inverse': ('level', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'level': ['unsigned']},
                                            'types': {'level': 'uint'}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'level': 'getLevel'}},
  'MItSubdVertex': {'enums': {},
                    'invertibles': [('setLevel', 'level')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'index': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the index of the current vertex in the vertex list for this subdiv object.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The index in the vertex list for the current vertex',
                                                          'qualifiers': [],
                                                          'type': 'MUint64'},
                                           'returnType': 'MUint64',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                                'isDone': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nIndicates if all of the vertices have been traversed yet.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' true All vertices have been traversed  false There are more vertices in the iteration  ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                'isValid': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nChecks if the iterator is valid.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Boolean to indicate whether the iterator is valid or not.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                'level': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the level of the subdiv object.',
                                           'inArgs': [],
                                           'inverse': ('setLevel', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The level.',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                                'next': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nAdvance to the next vertex in the iteration.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'reset': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReset the iterator to the first vertex.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                'setLevel': [{'argInfo': {'level': {'doc': 'Level of the subdiv ',
                                                                    'type': 'int'}},
                                              'args': [('level',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSets the level of the subdiv object',
                                              'inArgs': ['level'],
                                              'inverse': ('level', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'level': []},
                                              'types': {'level': 'int'}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'level': 'getLevel'}},
  'MItSurfaceCV': {'enums': {},
                   'invertibles': [('setPosition', 'position')],
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'currentItem': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the current CV in the iteration as a component.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The current CV in the interation',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                               'cv': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': True,
                                       'doc': '\n This method is obsolete. \n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The current CV in the interation',
                                                      'qualifiers': [],
                                                      'type': 'MObject'},
                                       'returnType': 'MObject',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                               'getIndex': [{'argInfo': {'indexU': {'doc': 'Storage for the u index ',
                                                                    'type': 'int'},
                                                         'indexV': {'doc': 'Storage for the v index',
                                                                    'type': 'int'}},
                                             'args': [('indexU',
                                                       'int',
                                                       'out'),
                                                      ('indexV',
                                                       'int',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the index of the current CV as it appears in CV array for this surface.',
                                             'inArgs': [],
                                             'outArgs': ['indexU',
                                                         'indexV'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'indexU': ['&'],
                                                                'indexV': ['&']},
                                             'types': {'indexU': 'int',
                                                       'indexV': 'int'}}],
                               'hasHistoryOnCreate': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method determines if the shape was created with history.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Boolean value: true if the shape has history, false otherwise.',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                               'index': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nGet the index of the current CV as it appears in CV array for this surface.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The index for the current CV in the iteration',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                               'isDone': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns  true  if the iteration is finished, i.e. there are no more CVs to iterate on.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Boolean value: true if there are no more CVs to iterate on, false otherwise.',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                               'isRowDone': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns  true  if the current row has no more CVs to iterate over. The row can be in the U or V direction depending on what value of  useURows  has been set in the constructor.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Boolean value: true if the current row in the iteration is finished, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                               'next': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nAdvance to the next CV in the iteration. If the iterator is already at the last CV then this method has no effect. Use  isDone  to determine if the iterator is at the last CV.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'nextRow': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nAdvance to the next row in the iteration. The row can be in the U or V direction depending on what value of  useURows  has been set in the constructor.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                               'position': [{'argInfo': {'space': {'doc': 'The coordinate space in which the CV is set ',
                                                                   'type': ('MSpace',
                                                                            'Space')}},
                                             'args': [('space',
                                                       ('MSpace',
                                                        'Space'),
                                                       'in')],
                                             'defaults': {'space': ('MSpace',
                                                                    'Space',
                                                                    'kObject')},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the position of the current CV in the iteration in the specified space.',
                                             'inArgs': ['space'],
                                             'inverse': ('setPosition',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The position of the current CV in the iteration',
                                                            'qualifiers': [],
                                                            'type': 'MPoint'},
                                             'returnType': 'MPoint',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                'space': []},
                                             'types': {'space': ('MSpace',
                                                                 'Space')}}],
                               'reset': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReset the iterator to the first CV.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}},
                                         {'argInfo': {'surface': {'doc': 'The surface for the iteration ',
                                                                  'type': 'MObject'},
                                                      'useURows': {'doc': 'If true then the iterator will iterate in the U direction, otherwise it will be in the V direction.',
                                                                   'type': 'bool'}},
                                          'args': [('surface',
                                                    'MObject',
                                                    'in'),
                                                   ('useURows',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'useURows': True},
                                          'deprecated': False,
                                          'doc': '\r\nReset the iterator to iterate over all CVs on the specified surface.',
                                          'inArgs': ['surface',
                                                     'useURows'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'surface': ['const',
                                                                         '&'],
                                                             'useURows': []},
                                          'types': {'surface': 'MObject',
                                                    'useURows': 'bool'}},
                                         {'argInfo': {'component': {'doc': 'A group of CVs to be iterated on ',
                                                                    'type': 'MObject'},
                                                      'surface': {'doc': 'The surface for the iteration ',
                                                                  'type': 'MDagPath'},
                                                      'useURows': {'doc': 'If true then the iterator will iterate in the U direction, otherwise it will be in the V direction.',
                                                                   'type': 'bool'}},
                                          'args': [('surface',
                                                    'MDagPath',
                                                    'in'),
                                                   ('component',
                                                    'MObject',
                                                    'in'),
                                                   ('useURows',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'component': 'MObject::kNullObj',
                                                       'useURows': True},
                                          'deprecated': False,
                                          'doc': '\r\nReset the iterator to iterate over the CVs of the given surface that are specified in the given component. If the component is NULL then the iteration will be over all CVs on the surface.',
                                          'inArgs': ['surface',
                                                     'component',
                                                     'useURows'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'component': ['const',
                                                                           '&'],
                                                             'surface': ['const',
                                                                         '&'],
                                                             'useURows': []},
                                          'types': {'component': 'MObject',
                                                    'surface': 'MDagPath',
                                                    'useURows': 'bool'}}],
                               'setPosition': [{'argInfo': {'point': {'doc': 'The new position for the current CV in the iteration ',
                                                                      'type': 'MPoint'},
                                                            'space': {'doc': 'The coordinate space in which the CV is set',
                                                                      'type': ('MSpace',
                                                                               'Space')}},
                                                'args': [('point',
                                                          'MPoint',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nSet the position of the current CV in the iteration to the specified point.',
                                                'inArgs': ['space'],
                                                'inverse': ('position',
                                                            True),
                                                'outArgs': ['point'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'point': ['const',
                                                                             '&'],
                                                                   'space': []},
                                                'types': {'point': 'MPoint',
                                                          'space': ('MSpace',
                                                                    'Space')}}],
                               'translateBy': [{'argInfo': {'space': {'doc': 'The coordinate space in which the CV is set',
                                                                      'type': ('MSpace',
                                                                               'Space')},
                                                            'vector': {'doc': 'The translation vector ',
                                                                       'type': 'MVector'}},
                                                'args': [('vector',
                                                          'MVector',
                                                          'out'),
                                                         ('space',
                                                          ('MSpace',
                                                           'Space'),
                                                          'in')],
                                                'defaults': {'space': ('MSpace',
                                                                       'Space',
                                                                       'kObject')},
                                                'deprecated': False,
                                                'doc': '\r\nMove the current CV in the iteration by the sepcified vector.',
                                                'inArgs': ['space'],
                                                'outArgs': ['vector'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'space': [],
                                                                   'vector': ['const',
                                                                              '&']},
                                                'types': {'space': ('MSpace',
                                                                    'Space'),
                                                          'vector': 'MVector'}}],
                               'updateSurface': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method is used to signal the surface that it has been changed and needs to redraw itself.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'position': 'getPosition'}},
  'MIteratorType': {'enums': {'objFilterType': {'valueDocs': {'dagPathObject': 'This is to indicate that the root of the iterator has to be reset to an',
                                                              'kMDagPathObject': 'This is to indicate that the root of the iterator has to be reset to an',
                                                              'kMObject': 'This is to indicate that the root of the iterator has to be reset to an',
                                                              'kMPlugObject': 'This is to indicate that the root of the iterator has to be reset to an',
                                                              'object': 'This is to indicate that the root of the iterator has to be reset to an',
                                                              'plugObject': 'This is to indicate that the root of the iterator has to be reset to an'},
                                                'values': "Enum('objFilterType', {'kMObject': 0, 'kMDagPathObject': 1, 'kMPlugObject': 2})"}},
                    'invertibles': [('setFilterType', 'getFilterType'),
                                    ('setFilterList', 'getFilterList'),
                                    ('setObjectType', 'getObjectType')],
                    'methods': {'filterListEnabled': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns whether the we are using a single filter on the iterator or a filter list.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                'getFilterList': [{'argInfo': {'listOfFilters': {'doc': 'Array of filters.',
                                                                                 'type': 'MIntArray'}},
                                                   'args': [('listOfFilters',
                                                             'MIntArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nGets the list of filters.',
                                                   'inArgs': [],
                                                   'inverse': ('setFilterList',
                                                               False),
                                                   'outArgs': ['listOfFilters'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'listOfFilters': ['&']},
                                                   'types': {'listOfFilters': 'MIntArray'}}],
                                'getFilterType': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the type of filter.',
                                                   'inArgs': [],
                                                   'inverse': ('setFilterType',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The filter type.',
                                                                  'qualifiers': [],
                                                                  'type': ('MFn',
                                                                           'Type')},
                                                   'returnType': ('MFn',
                                                                  'Type'),
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                'getObjectType': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the object type.',
                                                   'inArgs': [],
                                                   'inverse': ('setObjectType',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The object type.',
                                                                  'qualifiers': [],
                                                                  'type': ('MIteratorType',
                                                                           'objFilterType')},
                                                   'returnType': ('MIteratorType',
                                                                  'objFilterType'),
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                'setFilterList': [{'argInfo': {'listOfFilters': {'doc': 'List of MFn::Type filters. ',
                                                                                 'type': 'MIntArray'}},
                                                   'args': [('listOfFilters',
                                                             'MIntArray',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the filter list. The types of filters to be traversed in the iterator is added to an array and then passed in to this function. This also enables filter list usage on iterators, as opposed to single filter.',
                                                   'inArgs': ['listOfFilters'],
                                                   'inverse': ('getFilterList',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'listOfFilters': ['&']},
                                                   'types': {'listOfFilters': 'MIntArray'}}],
                                'setFilterType': [{'argInfo': {'type': {'doc': 'An object of type MFn::Type. ',
                                                                        'type': ('MFn',
                                                                                 'Type')}},
                                                   'args': [('type',
                                                             ('MFn',
                                                              'Type'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the filter type to be used in the iterator. See  MFn::Type  for the list of filter types that can be set.',
                                                   'inArgs': ['type'],
                                                   'inverse': ('getFilterType',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'type': []},
                                                   'types': {'type': ('MFn',
                                                                      'Type')}}],
                                'setObjectType': [{'argInfo': {'objFilterType': {'doc': 'Type specifying the type of object. ',
                                                                                 'type': ('MIteratorType',
                                                                                          'objFilterType')}},
                                                   'args': [('objFilterType',
                                                             ('MIteratorType',
                                                              'objFilterType'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the object type. This function should be used only when we want to reset the iterator root. Iterator root can be reset to either an  MObject , an  MDagPath  or to an  MPlug . For each of this, there is a corresponding enum value, which has to be used as an argument to this function.',
                                                   'inArgs': ['objFilterType'],
                                                   'inverse': ('getObjectType',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'objFilterType': []},
                                                   'types': {'objFilterType': ('MIteratorType',
                                                                               'objFilterType')}}]},
                    'pymelEnums': {'objFilterType': "Enum('objFilterType', [('object', 0), ('kMObject', 0), ('dagPathObject', 1), ('kMDagPathObject', 1), ('plugObject', 2), ('kMPlugObject', 2)], multiKeys=True)"}},
  'MLightLinks': {'enums': {},
                  'methods': {'getIgnoredLights': [{'argInfo': {'ignoredLights': {'doc': 'Returns the DAG paths of the lights that ignores the specified object or component.',
                                                                                  'type': 'MDagPathArray'},
                                                                'objectComponent': {'doc': 'If non-null, specifies that only lights that ignore the specified component on the object should be returned. Otherwise, only lights that ignore the entire object will be returned. ',
                                                                                    'type': 'MObject'},
                                                                'objectPath': {'doc': 'The object whose linked lights are desired. ',
                                                                               'type': 'MDagPath'}},
                                                    'args': [('objectPath',
                                                              'MDagPath',
                                                              'in'),
                                                             ('objectComponent',
                                                              'MObject',
                                                              'in'),
                                                             ('ignoredLights',
                                                              'MDagPathArray',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nQueries the light link table to find the lights that ignores a particular object or object component.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                    'inArgs': ['objectPath',
                                                               'objectComponent'],
                                                    'outArgs': ['ignoredLights'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'ignoredLights': ['&'],
                                                                       'objectComponent': ['const',
                                                                                           '&'],
                                                                       'objectPath': ['const',
                                                                                      '&']},
                                                    'types': {'ignoredLights': 'MDagPathArray',
                                                              'objectComponent': 'MObject',
                                                              'objectPath': 'MDagPath'}}],
                              'getIgnoredObjects': [{'argInfo': {'ignoredObjects': {'doc': 'Returns the list of objects/components that are ignored to the specified light.',
                                                                                    'type': 'MSelectionList'},
                                                                 'lightPath': {'doc': 'The light whose ignored objects are desired. ',
                                                                               'type': 'MDagPath'}},
                                                     'args': [('lightPath',
                                                               'MDagPath',
                                                               'in'),
                                                              ('ignoredObjects',
                                                               'MSelectionList',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nQueries the light link table to find the objects or object components that are ignored to a particular light.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                     'inArgs': ['lightPath'],
                                                     'outArgs': ['ignoredObjects'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'ignoredObjects': ['&'],
                                                                        'lightPath': ['const',
                                                                                      '&']},
                                                     'types': {'ignoredObjects': 'MSelectionList',
                                                               'lightPath': 'MDagPath'}}],
                              'getLinkedLights': [{'argInfo': {'linkedLights': {'doc': 'Returns the DAG paths of the lights linked to the specified object or component.',
                                                                                'type': 'MDagPathArray'},
                                                               'objectComponent': {'doc': 'If non-null, specifies that only lights linked to the specified component on the object should be returned. Otherwise, only lights linked to the entire object will be returned. ',
                                                                                   'type': 'MObject'},
                                                               'objectPath': {'doc': 'The object whose linked lights are desired. ',
                                                                              'type': 'MDagPath'}},
                                                   'args': [('objectPath',
                                                             'MDagPath',
                                                             'in'),
                                                            ('objectComponent',
                                                             'MObject',
                                                             'in'),
                                                            ('linkedLights',
                                                             'MDagPathArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nQueries the light link table to find the lights that are linked to a particular object or object component.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                   'inArgs': ['objectPath',
                                                              'objectComponent'],
                                                   'outArgs': ['linkedLights'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'linkedLights': ['&'],
                                                                      'objectComponent': ['const',
                                                                                          '&'],
                                                                      'objectPath': ['const',
                                                                                     '&']},
                                                   'types': {'linkedLights': 'MDagPathArray',
                                                             'objectComponent': 'MObject',
                                                             'objectPath': 'MDagPath'}}],
                              'getLinkedObjects': [{'argInfo': {'lightPath': {'doc': 'The light whose linked objects are desired. ',
                                                                              'type': 'MDagPath'},
                                                                'linkedObjects': {'doc': 'Returns the list of objects/components that are linked to the specified light.',
                                                                                  'type': 'MSelectionList'}},
                                                    'args': [('lightPath',
                                                              'MDagPath',
                                                              'in'),
                                                             ('linkedObjects',
                                                              'MSelectionList',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nQueries the light link table to find the objects or object components that are linked to a particular light.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                    'inArgs': ['lightPath'],
                                                    'outArgs': ['linkedObjects'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'lightPath': ['const',
                                                                                     '&'],
                                                                       'linkedObjects': ['&']},
                                                    'types': {'lightPath': 'MDagPath',
                                                              'linkedObjects': 'MSelectionList'}}],
                              'getShadowIgnoredLights': [{'argInfo': {'ignoredLights': {'doc': 'Returns the DAG paths of the lights that shadow ignores the specified object or component.',
                                                                                        'type': 'MDagPathArray'},
                                                                      'objectComponent': {'doc': 'If non-null, specifies that only lights that shadow ignore the specified component on the object should be returned. Otherwise, only lights that shadow ignore the entire object will be returned. ',
                                                                                          'type': 'MObject'},
                                                                      'objectPath': {'doc': 'The object whose shadow ignored lights are desired. ',
                                                                                     'type': 'MDagPath'}},
                                                          'args': [('objectPath',
                                                                    'MDagPath',
                                                                    'in'),
                                                                   ('objectComponent',
                                                                    'MObject',
                                                                    'in'),
                                                                   ('ignoredLights',
                                                                    'MDagPathArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nQueries the light link table to find the lights that ignore a particular object or object component when casting shadows. This is referred to as shadow ignoring the objects.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                          'inArgs': ['objectPath',
                                                                     'objectComponent'],
                                                          'outArgs': ['ignoredLights'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'ignoredLights': ['&'],
                                                                             'objectComponent': ['const',
                                                                                                 '&'],
                                                                             'objectPath': ['const',
                                                                                            '&']},
                                                          'types': {'ignoredLights': 'MDagPathArray',
                                                                    'objectComponent': 'MObject',
                                                                    'objectPath': 'MDagPath'}}],
                              'getShadowIgnoredObjects': [{'argInfo': {'ignoredObjects': {'doc': 'Returns the list of objects/components that are shadow ignored to the specified light.',
                                                                                          'type': 'MSelectionList'},
                                                                       'lightPath': {'doc': 'The light whose shadow ignored objects are desired. ',
                                                                                     'type': 'MDagPath'}},
                                                           'args': [('lightPath',
                                                                     'MDagPath',
                                                                     'in'),
                                                                    ('ignoredObjects',
                                                                     'MSelectionList',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nQueries the light link table to find the objects or object components that are ignored to a particular light when calculating shadows. These are referred to as shadow ignored objects.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                           'inArgs': ['lightPath'],
                                                           'outArgs': ['ignoredObjects'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'ignoredObjects': ['&'],
                                                                              'lightPath': ['const',
                                                                                            '&']},
                                                           'types': {'ignoredObjects': 'MSelectionList',
                                                                     'lightPath': 'MDagPath'}}],
                              'getShadowLinkedLights': [{'argInfo': {'linkedLights': {'doc': 'Returns the DAG paths of the lights shadow linked to the specified object or component.',
                                                                                      'type': 'MDagPathArray'},
                                                                     'objectComponent': {'doc': 'If non-null, specifies that only lights shadow linked to the specified component on the object should be returned. Otherwise, only lights shadow linked to the entire object will be returned. ',
                                                                                         'type': 'MObject'},
                                                                     'objectPath': {'doc': 'The object whose shadow linked lights are desired. ',
                                                                                    'type': 'MDagPath'}},
                                                         'args': [('objectPath',
                                                                   'MDagPath',
                                                                   'in'),
                                                                  ('objectComponent',
                                                                   'MObject',
                                                                   'in'),
                                                                  ('linkedLights',
                                                                   'MDagPathArray',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nQueries the light link table to find the lights that are shadow linked to a particular object or object component.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                         'inArgs': ['objectPath',
                                                                    'objectComponent'],
                                                         'outArgs': ['linkedLights'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'linkedLights': ['&'],
                                                                            'objectComponent': ['const',
                                                                                                '&'],
                                                                            'objectPath': ['const',
                                                                                           '&']},
                                                         'types': {'linkedLights': 'MDagPathArray',
                                                                   'objectComponent': 'MObject',
                                                                   'objectPath': 'MDagPath'}}],
                              'getShadowLinkedObjects': [{'argInfo': {'lightPath': {'doc': 'The light whose shadow linked objects are desired. ',
                                                                                    'type': 'MDagPath'},
                                                                      'linkedObjects': {'doc': 'Returns the list of objects/components that are shadow linked to the specified light.',
                                                                                        'type': 'MSelectionList'}},
                                                          'args': [('lightPath',
                                                                    'MDagPath',
                                                                    'in'),
                                                                   ('linkedObjects',
                                                                    'MSelectionList',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nQueries the light link table to find the objects or object components that are shadow linked to a particular light.  parseLinks()  must have been called at some point to generate the table that is being queried.',
                                                          'inArgs': ['lightPath'],
                                                          'outArgs': ['linkedObjects'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'lightPath': ['const',
                                                                                           '&'],
                                                                             'linkedObjects': ['&']},
                                                          'types': {'lightPath': 'MDagPath',
                                                                    'linkedObjects': 'MSelectionList'}}],
                              'parseLinks': [{'argInfo': {'componentSupport': {'doc': 'Use component level light links where specified.',
                                                                               'type': 'bool'},
                                                          'linkNode': {'doc': 'The light linker node to be parsed. If this parameter is set to the null object (the default), then all light linker nodes in the scene will be parsed. It is highly recommended that this default be used. ',
                                                                       'type': 'MObject'},
                                                          'stream': {'doc': "Stream to which debugging information is output when 'verbose' is set to true. ",
                                                                     'type': ('std',
                                                                              'ostream')},
                                                          'useIgnore': {'doc': 'light/object relationship will be queried using getIgnoreObjects or getIgnoreLights. getLinkedObjects and getLinkedLights are not affected. ',
                                                                        'type': 'bool'},
                                                          'verbose': {'doc': 'Enables verbose output from the parsing procedure (default false). ',
                                                                      'type': 'bool'}},
                                              'args': [('linkNode',
                                                        'MObject',
                                                        'in'),
                                                       ('verbose',
                                                        'bool',
                                                        'in'),
                                                       ('stream',
                                                        ('std',
                                                         'ostream'),
                                                        'in'),
                                                       ('useIgnore',
                                                        'bool',
                                                        'in'),
                                                       ('componentSupport',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'componentSupport': True,
                                                           'linkNode': 'MObject::kNullObj',
                                                           'stream': None,
                                                           'useIgnore': False,
                                                           'verbose': False},
                                              'deprecated': False,
                                              'doc': '\r\nCompiles the information contained in a light linker node into a table of object/light links. The  getLinkedLights()  and  getLinkedObjects()  methods are used to query this table.',
                                              'inArgs': ['linkNode',
                                                         'verbose',
                                                         'stream',
                                                         'useIgnore',
                                                         'componentSupport'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'componentSupport': [],
                                                                 'linkNode': ['const',
                                                                              '&'],
                                                                 'stream': ['*'],
                                                                 'useIgnore': [],
                                                                 'verbose': []},
                                              'types': {'componentSupport': 'bool',
                                                        'linkNode': 'MObject',
                                                        'stream': ('std',
                                                                   'ostream'),
                                                        'useIgnore': 'bool',
                                                        'verbose': 'bool'}}]},
                  'pymelEnums': {}},
  'MLockMessage': {'enums': {'LockDAGEvent': {'valueDocs': {'childReorder': 'Lock query on a child add action.',
                                                            'createChildInstance': 'Lock query on node whose children will be instanced.',
                                                            'createNodeInstance': 'Lock query on an instance event.',
                                                            'createParentInstance': 'Lock query on node whose parent will be instanced.',
                                                            'group': 'Lock query on group action.',
                                                            'invalidDAG': 'Invalid DAG event received.',
                                                            'kChildReorder': 'Lock query on a child add action.',
                                                            'kCreateChildInstance': 'Lock query on node whose children will be instanced.',
                                                            'kCreateNodeInstance': 'Lock query on an instance event.',
                                                            'kCreateParentInstance': 'Lock query on node whose parent will be instanced.',
                                                            'kGroup': 'Lock query on group action.',
                                                            'kInvalidDAG': 'Invalid DAG event received.',
                                                            'kLastDAG': 'Used for internal bounds checking.',
                                                            'kReparent': 'Lock query on reparent action.',
                                                            'kUnGroup': 'Lock query on ungroup action.',
                                                            'lastDAG': 'Used for internal bounds checking.',
                                                            'reparent': 'Lock query on reparent action.',
                                                            'unGroup': 'Lock query on ungroup action.'},
                                              'values': "Enum('LockDAGEvent', {'kInvalidDAG': 0, 'kGroup': 1, 'kUnGroup': 2, 'kReparent': 3, 'kChildReorder': 4, 'kCreateNodeInstance': 5, 'kCreateChildInstance': 6, 'kCreateParentInstance': 7, 'kLastDAG': 8})"},
                             'LockEvent': {'valueDocs': {'addAttr': 'Lock query on an add attribute event.',
                                                         'delete': 'Lock query on a delete event.',
                                                         'invalid': 'Invalid node lock event received.',
                                                         'kAddAttr': 'Lock query on an add attribute event.',
                                                         'kDelete': 'Lock query on a delete event.',
                                                         'kInvalid': 'Invalid node lock event received.',
                                                         'kLast': 'Used for internal bounds checking.',
                                                         'kLockAttr': 'Lock query on a lock attribute event.',
                                                         'kLockNode': 'Lock query on a lock event.',
                                                         'kRemoveAttr': 'Lock query on an remove attribute event.',
                                                         'kRename': 'Lock query on a rename event.',
                                                         'kRenameAttr': 'Lock query on an rename attribute event.',
                                                         'kUnlockAttr': 'Lock query on an unlock attribute event.',
                                                         'kUnlockNode': 'Lock query on an unlock event.',
                                                         'last': 'Used for internal bounds checking.',
                                                         'lockAttr': 'Lock query on a lock attribute event.',
                                                         'lockNode': 'Lock query on a lock event.',
                                                         'removeAttr': 'Lock query on an remove attribute event.',
                                                         'rename': 'Lock query on a rename event.',
                                                         'renameAttr': 'Lock query on an rename attribute event.',
                                                         'unlockAttr': 'Lock query on an unlock attribute event.',
                                                         'unlockNode': 'Lock query on an unlock event.'},
                                           'values': "Enum('LockEvent', {'kInvalid': 0, 'kRename': 1, 'kDelete': 2, 'kLockNode': 3, 'kUnlockNode': 4, 'kAddAttr': 5, 'kRemoveAttr': 6, 'kRenameAttr': 7, 'kUnlockAttr': 8, 'kLockAttr': 9, 'kLast': 10})"},
                             'LockPlugEvent': {'valueDocs': {'invalidPlug': 'An invalid plug event received.',
                                                             'kInvalidPlug': 'An invalid plug event received.',
                                                             'kLastPlug': 'Used for internal bounds checking.',
                                                             'kPlugAttrValChange': 'Plug lock query on plug value change.',
                                                             'kPlugConnect': 'Plug lock query on a connect to a locked attribute.',
                                                             'kPlugDisconnect': 'Plug lock query on a disconnect from a locked source attribute.',
                                                             'kPlugLockAttr': 'User is trying to lock the plug.',
                                                             'kPlugRemoveAttr': 'Plug lock query on a remove attribute event.',
                                                             'kPlugRenameAttr': 'Plug lock query on a rename attribute event.',
                                                             'kPlugUnlockAttr': 'User is trying to unlock the plug.',
                                                             'lastPlug': 'Used for internal bounds checking.',
                                                             'plugAttrValChange': 'Plug lock query on plug value change.',
                                                             'plugConnect': 'Plug lock query on a connect to a locked attribute.',
                                                             'plugDisconnect': 'Plug lock query on a disconnect from a locked source attribute.',
                                                             'plugLockAttr': 'User is trying to lock the plug.',
                                                             'plugRemoveAttr': 'Plug lock query on a remove attribute event.',
                                                             'plugRenameAttr': 'Plug lock query on a rename attribute event.',
                                                             'plugUnlockAttr': 'User is trying to unlock the plug.'},
                                               'values': "Enum('LockPlugEvent', {'kInvalidPlug': 0, 'kPlugLockAttr': 1, 'kPlugUnlockAttr': 2, 'kPlugAttrValChange': 3, 'kPlugRemoveAttr': 4, 'kPlugRenameAttr': 5, 'kPlugConnect': 6, 'kPlugDisconnect': 7, 'kLastPlug': 8})"}},
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'setNodeLockDAGQueryCallback': [{'argInfo': {'clientData': {'doc': 'Client data that should be passed back to the callback. ',
                                                                                           'type': 'void'},
                                                                            'dagPath': {'doc': 'The path to attach the callback. ',
                                                                                        'type': 'MDagPath'},
                                                                            'func': {'doc': '- Pointer to the callback function. ',
                                                                                     'type': ('MLockMessage',
                                                                                              'MLockDagEventFunction')}},
                                                                'args': [('dagPath',
                                                                          'MDagPath',
                                                                          'in'),
                                                                         ('func',
                                                                          ('MLockMessage',
                                                                           'MLockDagEventFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': '\nThis methods registers a callback that is invoked in any situation involving a locking condition on DAG level changes. When called, the API user can make a decision on how to handle the given locking situation. The programmer can either accept the default action, or they can deny the default action. The decision is returned through a decision variable which is passed to the callback function.',
                                                                'inArgs': ['dagPath',
                                                                           'func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'A unique id for the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'dagPath': ['&'],
                                                                                   'func': []},
                                                                'types': {'clientData': 'void',
                                                                          'dagPath': 'MDagPath',
                                                                          'func': ('MLockMessage',
                                                                                   'MLockDagEventFunction')}}],
                               'setNodeLockQueryCallback': [{'argInfo': {'clientData': {'doc': '- Client data that should be passed back to the callback. ',
                                                                                        'type': 'void'},
                                                                         'func': {'doc': '- Pointer to the callback function. ',
                                                                                  'type': ('MLockMessage',
                                                                                           'MLockEventFunction')},
                                                                         'node': {'doc': '- The node to register the callback for. ',
                                                                                  'type': 'MObject'}},
                                                             'args': [('node',
                                                                       'MObject',
                                                                       'in'),
                                                                      ('func',
                                                                       ('MLockMessage',
                                                                        'MLockEventFunction'),
                                                                       'in'),
                                                                      ('clientData',
                                                                       'void',
                                                                       'in')],
                                                             'defaults': {'clientData': None},
                                                             'deprecated': False,
                                                             'doc': '\nThis methods registers a callback that is invoked in any locking condition on node properties, e.g. name, lock status, etc. When called, the API user can make a decision on how to handle the given locking situation. The programmer can either accept the default action, or they can deny the default action. The decision is returned through a decision variable which is passed to the callback function.',
                                                             'inArgs': ['node',
                                                                        'func',
                                                                        'clientData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'A unique id for the callback.',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'clientData': ['*'],
                                                                                'func': [],
                                                                                'node': ['&']},
                                                             'types': {'clientData': 'void',
                                                                       'func': ('MLockMessage',
                                                                                'MLockEventFunction'),
                                                                       'node': 'MObject'}}],
                               'setPlugLockQueryCallback': [{'argInfo': {'clientData': {'doc': '- Client data that should be passed back to the callback. ',
                                                                                        'type': 'void'},
                                                                         'func': {'doc': '- Pointer to the callback function. ',
                                                                                  'type': ('MLockMessage',
                                                                                           'MLockPlugEventFunction')},
                                                                         'plug': {'doc': '- The plug to attach the callback. ',
                                                                                  'type': 'MPlug'}},
                                                             'args': [('plug',
                                                                       'MPlug',
                                                                       'in'),
                                                                      ('func',
                                                                       ('MLockMessage',
                                                                        'MLockPlugEventFunction'),
                                                                       'in'),
                                                                      ('clientData',
                                                                       'void',
                                                                       'in')],
                                                             'defaults': {'clientData': None},
                                                             'deprecated': False,
                                                             'doc': '\nThis method registers a callback that is invoked in any locking condition on a plug, e.g. plug unlock, plug lock, connections, etc. When the callback is invoked, the API programmer can make a decision on how to handle the given locking situation. The programmer can either accept the default action, or they can deny the default action. The decision is made through the decision variable described above.',
                                                             'inArgs': ['plug',
                                                                        'func',
                                                                        'clientData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'A unique id for the callback.',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'clientData': ['*'],
                                                                                'func': [],
                                                                                'plug': ['&']},
                                                             'types': {'clientData': 'void',
                                                                       'func': ('MLockMessage',
                                                                                'MLockPlugEventFunction'),
                                                                       'plug': 'MPlug'}},
                                                            {'argInfo': {'clientData': {'doc': '- Client data that should be passed back to the callback. ',
                                                                                        'type': 'void'},
                                                                         'func': {'doc': '- Pointer to the callback function. ',
                                                                                  'type': ('MLockMessage',
                                                                                           'MLockPlugEventFunction')},
                                                                         'node': {'doc': '- The node to attach the callback. ',
                                                                                  'type': 'MObject'}},
                                                             'args': [('node',
                                                                       'MObject',
                                                                       'in'),
                                                                      ('func',
                                                                       ('MLockMessage',
                                                                        'MLockPlugEventFunction'),
                                                                       'in'),
                                                                      ('clientData',
                                                                       'void',
                                                                       'in')],
                                                             'defaults': {'clientData': None},
                                                             'deprecated': False,
                                                             'doc': '\nThis method registers a callback that is invoked in any locking condition on any plug of a given node, e.g. plug unlock, plug lock, connections, etc. When the callback is invoked, the API programmer can make a decision on how to handle the given locking situation. The programmer can either accept the default action, or they can deny the default action. The decision is returned through a decision variable which is passed to the callback function.',
                                                             'inArgs': ['node',
                                                                        'func',
                                                                        'clientData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'A unique id for the callback.',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'clientData': ['*'],
                                                                                'func': [],
                                                                                'node': ['&']},
                                                             'types': {'clientData': 'void',
                                                                       'func': ('MLockMessage',
                                                                                'MLockPlugEventFunction'),
                                                                       'node': 'MObject'}}]},
                   'pymelEnums': {'LockDAGEvent': "Enum('LockDAGEvent', [('invalidDAG', 0), ('kInvalidDAG', 0), ('group', 1), ('kGroup', 1), ('unGroup', 2), ('kUnGroup', 2), ('reparent', 3), ('kReparent', 3), ('childReorder', 4), ('kChildReorder', 4), ('createNodeInstance', 5), ('kCreateNodeInstance', 5), ('createChildInstance', 6), ('kCreateChildInstance', 6), ('createParentInstance', 7), ('kCreateParentInstance', 7), ('lastDAG', 8), ('kLastDAG', 8)], multiKeys=True)",
                                  'LockEvent': "Enum('LockEvent', [('invalid', 0), ('kInvalid', 0), ('rename', 1), ('kRename', 1), ('delete', 2), ('kDelete', 2), ('lockNode', 3), ('kLockNode', 3), ('unlockNode', 4), ('kUnlockNode', 4), ('addAttr', 5), ('kAddAttr', 5), ('removeAttr', 6), ('kRemoveAttr', 6), ('renameAttr', 7), ('kRenameAttr', 7), ('unlockAttr', 8), ('kUnlockAttr', 8), ('lockAttr', 9), ('kLockAttr', 9), ('last', 10), ('kLast', 10)], multiKeys=True)",
                                  'LockPlugEvent': "Enum('LockPlugEvent', [('invalidPlug', 0), ('kInvalidPlug', 0), ('plugLockAttr', 1), ('kPlugLockAttr', 1), ('plugUnlockAttr', 2), ('kPlugUnlockAttr', 2), ('plugAttrValChange', 3), ('kPlugAttrValChange', 3), ('plugRemoveAttr', 4), ('kPlugRemoveAttr', 4), ('plugRenameAttr', 5), ('kPlugRenameAttr', 5), ('plugConnect', 6), ('kPlugConnect', 6), ('plugDisconnect', 7), ('kPlugDisconnect', 7), ('lastPlug', 8), ('kLastPlug', 8)], multiKeys=True)"}},
  'MManipData': {'enums': {},
                 'methods': {'asBool': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the manipulator data as a bool.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'asDouble': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the manipulator data as a double.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                             'asFloat': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the manipulator data as a float.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                             'asLong': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the manipulator data as a int',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'asMObject': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the manipulator data as an  MObject . The MObjects returned from this method are created and used by  MFnData  or classes derived from  MFnData .',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'asShort': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the manipulator data as a short.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'short'},
                                          'returnType': 'short',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                             'asUnsigned': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the manipulator data as an unsigned int.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'isSimple': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns whether or not the manipulator data is simple or complex. Simple data is used to represent bool, short, int, unsigned int, float, and double types. Complex data is used to represent MObjects created by  MFnData , or classes derived from  MFnData .',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                 'pymelEnums': {}},
  'MMaterial': {'enums': {'MtextureChannel': {'valueDocs': {'ambientColor': '',
                                                            'bumpMap': '',
                                                            'color': 'nop',
                                                            'cosinePower': 'Phong only.',
                                                            'diffuse': '',
                                                            'eccentricity': 'Blinn only.',
                                                            'highlightSize': 'PhongE only.',
                                                            'incandescence': '',
                                                            'kAmbientColor': '',
                                                            'kBumpMap': '',
                                                            'kColor': 'nop',
                                                            'kCosinePower': 'Phong only.',
                                                            'kDiffuse': '',
                                                            'kEccentricity': 'Blinn only.',
                                                            'kHighlightSize': 'PhongE only.',
                                                            'kIncandescence': '',
                                                            'kReflectedColor': 'Blinn and Phong(E) only.',
                                                            'kReflectivity': 'Blinn and Phong(E) only.',
                                                            'kRoughness': 'PhongE only.',
                                                            'kSpecularColor': 'Blinn and Phong(E) only.',
                                                            'kSpecularRollOff': 'Blinn only.',
                                                            'kTransluscence': '',
                                                            'kTransparency': '',
                                                            'kWhiteness': 'PhongE only.',
                                                            'reflectedColor': 'Blinn and Phong(E) only.',
                                                            'reflectivity': 'Blinn and Phong(E) only.',
                                                            'roughness': 'PhongE only.',
                                                            'specularColor': 'Blinn and Phong(E) only.',
                                                            'specularRollOff': 'Blinn only.',
                                                            'transluscence': '',
                                                            'transparency': '',
                                                            'whiteness': 'PhongE only.'},
                                              'values': "Enum('MtextureChannel', {'kColor': 0, 'kTransparency': 1, 'kAmbientColor': 2, 'kIncandescence': 3, 'kBumpMap': 4, 'kDiffuse': 5, 'kTransluscence': 6, 'kRoughness': 7, 'kHighlightSize': 8, 'kWhiteness': 9, 'kCosinePower': 10, 'kEccentricity': 11, 'kSpecularRollOff': 12, 'kSpecularColor': 13, 'kReflectivity': 14, 'kReflectedColor': 15})"}},
                'methods': {'applyTexture': [{'argInfo': {'data': {'doc': 'the draw data from the draw request ',
                                                                   'type': 'MDrawData'},
                                                          'view': {'doc': 'the view in which the textured drawing is to take place ',
                                                                   'type': 'M3dView'}},
                                              'args': [('view',
                                                        'M3dView',
                                                        'in'),
                                                       ('data',
                                                        'MDrawData',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nFor materials that have texture, this method must be used before the OpenGL drawing to apply the texture to the current view. This method should be called from within your  MPxSurfaceShapeUI::draw  method.',
                                              'inArgs': ['view', 'data'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'data': ['const',
                                                                          '&'],
                                                                 'view': ['&']},
                                              'types': {'data': 'MDrawData',
                                                        'view': 'M3dView'}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'defaultMaterial': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the default material. There will always be a default material in the scene and therefore the result of this function should always succeed. The default material will correspond to the initialShadingGroup node that is in the scene.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The default material returned as a MMaterial object. ',
                                                                'qualifiers': [],
                                                                'type': 'MMaterial'},
                                                 'returnType': 'MMaterial',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                            'evaluateDiffuse': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nPerform necessary evaluation to be able to get diffuse back.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                            'evaluateEmission': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nPerform necessary evaluation to be able to get emission back.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                            'evaluateMaterial': [{'argInfo': {'path': {'doc': 'path to the object',
                                                                       'type': 'MDagPath'},
                                                              'view': {'doc': 'the view ',
                                                                       'type': 'M3dView'}},
                                                  'args': [('view',
                                                            'M3dView',
                                                            'in'),
                                                           ('path',
                                                            'MDagPath',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nEvaluate a material. Must be called before evaluating or getting any material properties.',
                                                  'inArgs': ['view',
                                                             'path'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'path': ['const',
                                                                              '&'],
                                                                     'view': ['&']},
                                                  'types': {'path': 'MDagPath',
                                                            'view': 'M3dView'}}],
                            'evaluateShininess': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nPerform necessary evaluation to be able to get shininess back.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                            'evaluateSpecular': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nPerform necessary evaluation to be able to get specular back.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                            'evaluateTexture': [{'argInfo': {'data': {'doc': 'draw request data to carry the texture information',
                                                                      'type': 'MDrawData'}},
                                                 'args': [('data',
                                                           'MDrawData',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nEvaluate texturing related information. Must be called before getting any texture properties such as  getHasTransparency() ,  getTextureTransformation()  and  applyTexture() .',
                                                 'inArgs': ['data'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'data': ['&']},
                                                 'types': {'data': 'MDrawData'}}],
                            'evaluateTextureTransformation': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': True,
                                                               'doc': '\n This method is obsolete. \n',
                                                               'inArgs': [],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               'types': {}}],
                            'getDiffuse': [{'argInfo': {'color': {'doc': 'storage for the diffuse color',
                                                                  'type': 'MColor'}},
                                            'args': [('color',
                                                      'MColor',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nGet the GL diffuse color.',
                                            'inArgs': [],
                                            'outArgs': ['color'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'color': ['&']},
                                            'types': {'color': 'MColor'}}],
                            'getEmission': [{'argInfo': {'color': {'doc': 'storage for the emission color',
                                                                   'type': 'MColor'}},
                                             'args': [('color',
                                                       'MColor',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the GL emission color.',
                                             'inArgs': [],
                                             'outArgs': ['color'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'color': ['&']},
                                             'types': {'color': 'MColor'}}],
                            'getHasTransparency': [{'argInfo': {'value': {'doc': 'True if material or texture has transparency, false otherwise.',
                                                                          'type': 'bool'}},
                                                    'args': [('value',
                                                              'bool',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDetermine if material or texture has transparency.',
                                                    'inArgs': [],
                                                    'outArgs': ['value'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'value': ['&']},
                                                    'types': {'value': 'bool'}}],
                            'getHwShaderNode': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the hardware shader node. If this material has a hardware shader, a pointer to it will be returned in hwShader. If there is no hardware shader, hwShader will be set to NULL.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Pointer to hardware shader node.',
                                                                'qualifiers': ['*'],
                                                                'type': 'MPxHwShaderNode'},
                                                 'returnType': 'MPxHwShaderNode',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                            'getShininess': [{'argInfo': {'value': {'doc': 'storage for shininess',
                                                                    'type': 'float'}},
                                              'args': [('value',
                                                        'float',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the GL shininess.',
                                              'inArgs': [],
                                              'outArgs': ['value'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'value': ['&']},
                                              'types': {'value': 'float'}}],
                            'getSpecular': [{'argInfo': {'color': {'doc': 'storage for the specular color',
                                                                   'type': 'MColor'}},
                                             'args': [('color',
                                                       'MColor',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the GL specular color.',
                                             'inArgs': [],
                                             'outArgs': ['color'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'color': ['&']},
                                             'types': {'color': 'MColor'}}],
                            'getTextureTransformation': [{'argInfo': {'data': {'doc': 'the draw data from the draw request ',
                                                                               'type': 'MDrawData'},
                                                                      'texXform': {'doc': 'storage for the texture transformation',
                                                                                   'type': 'MMatrix'}},
                                                          'args': [('data',
                                                                    'MDrawData',
                                                                    'in'),
                                                                   ('texXform',
                                                                    'MMatrix',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGet the current textures transformation.',
                                                          'inArgs': ['data'],
                                                          'outArgs': ['texXform'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'data': ['const',
                                                                                      '&'],
                                                                             'texXform': ['&']},
                                                          'types': {'data': 'MDrawData',
                                                                    'texXform': 'MMatrix'}},
                                                         {'argInfo': {'data': {'doc': 'the draw data from the draw request ',
                                                                               'type': 'MDrawData'},
                                                                      'rotateFrame': {'doc': 'storage for rotatation value of the frame coordinates',
                                                                                      'type': 'float'},
                                                                      'rotateUV': {'doc': 'storage for rotatation value of the UV coordinates ',
                                                                                   'type': 'float'},
                                                                      'scaleU': {'doc': 'storage for u scale value ',
                                                                                 'type': 'float'},
                                                                      'scaleV': {'doc': 'storage for v scale value ',
                                                                                 'type': 'float'},
                                                                      'translateU': {'doc': 'storage for u translation value ',
                                                                                     'type': 'float'},
                                                                      'translateV': {'doc': 'storage for v translation value ',
                                                                                     'type': 'float'}},
                                                          'args': [('data',
                                                                    'MDrawData',
                                                                    'in'),
                                                                   ('rotateUV',
                                                                    'float',
                                                                    'out'),
                                                                   ('scaleU',
                                                                    'float',
                                                                    'out'),
                                                                   ('scaleV',
                                                                    'float',
                                                                    'out'),
                                                                   ('translateU',
                                                                    'float',
                                                                    'out'),
                                                                   ('translateV',
                                                                    'float',
                                                                    'out'),
                                                                   ('rotateFrame',
                                                                    'float',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGet the current textures transformation.',
                                                          'inArgs': ['data'],
                                                          'outArgs': ['rotateUV',
                                                                      'scaleU',
                                                                      'scaleV',
                                                                      'translateU',
                                                                      'translateV',
                                                                      'rotateFrame'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'data': ['const',
                                                                                      '&'],
                                                                             'rotateFrame': ['&'],
                                                                             'rotateUV': ['&'],
                                                                             'scaleU': ['&'],
                                                                             'scaleV': ['&'],
                                                                             'translateU': ['&'],
                                                                             'translateV': ['&']},
                                                          'types': {'data': 'MDrawData',
                                                                    'rotateFrame': 'float',
                                                                    'rotateUV': 'float',
                                                                    'scaleU': 'float',
                                                                    'scaleV': 'float',
                                                                    'translateU': 'float',
                                                                    'translateV': 'float'}},
                                                         {'argInfo': {'rotate': {'doc': 'storage for rotate value',
                                                                                 'type': 'float'},
                                                                      'scaleU': {'doc': 'storage for u scale value ',
                                                                                 'type': 'float'},
                                                                      'scaleV': {'doc': 'storage for v scale value ',
                                                                                 'type': 'float'},
                                                                      'translateU': {'doc': 'storage for u translation value ',
                                                                                     'type': 'float'},
                                                                      'translateV': {'doc': 'storage for v translation value ',
                                                                                     'type': 'float'}},
                                                          'args': [('scaleU',
                                                                    'float',
                                                                    'out'),
                                                                   ('scaleV',
                                                                    'float',
                                                                    'out'),
                                                                   ('translateU',
                                                                    'float',
                                                                    'out'),
                                                                   ('translateV',
                                                                    'float',
                                                                    'out'),
                                                                   ('rotate',
                                                                    'float',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': True,
                                                          'doc': '\n This method is obsolete. \n',
                                                          'inArgs': [],
                                                          'outArgs': ['scaleU',
                                                                      'scaleV',
                                                                      'translateU',
                                                                      'translateV',
                                                                      'rotate'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'rotate': ['&'],
                                                                             'scaleU': ['&'],
                                                                             'scaleV': ['&'],
                                                                             'translateU': ['&'],
                                                                             'translateV': ['&']},
                                                          'types': {'rotate': 'float',
                                                                    'scaleU': 'float',
                                                                    'scaleV': 'float',
                                                                    'translateU': 'float',
                                                                    'translateV': 'float'}}],
                            'materialIsTextured': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDo we have a texture (evaluated or not).',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True if the material is textured, false otherwise. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                            'setMaterial': [{'argInfo': {'hasTransparency': {'doc': 'whether the material has transparency',
                                                                             'type': 'bool'},
                                                         'path': {'doc': 'path to the object ',
                                                                  'type': 'MDagPath'}},
                                             'args': [('path',
                                                       'MDagPath',
                                                       'in'),
                                                      ('hasTransparency',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the current GL material.',
                                             'inArgs': ['path',
                                                        'hasTransparency'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'hasTransparency': [],
                                                                'path': ['const',
                                                                         '&']},
                                             'types': {'hasTransparency': 'bool',
                                                       'path': 'MDagPath'}}],
                            'shadingEngine': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the shading engined associated with this material.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                            'textureImage': [{'argInfo': {'chan': {'doc': 'Texture channel to check. ',
                                                                   'type': ('MMaterial',
                                                                            'MtextureChannel')},
                                                          'color': {'doc': "Either the mapped or unmapped color. If the channel is mapped then an RGBA value of (1,1,1,1) will be returned, otherwise the unmapped channel's current color value will be returned. ",
                                                                    'type': 'MColor'},
                                                          'dagPath': {'doc': 'Optional dag path to object. An object path is required to produce texture maps from non-2D procedural textures. ',
                                                                      'type': 'MDagPath'},
                                                          'image': {'doc': 'The image retrieved. If no image could be retrieve, the value will not change. ',
                                                                    'type': 'MImage'},
                                                          'mapped': {'doc': 'Whether the channel is mapped or not (true or false) ',
                                                                     'type': 'bool'},
                                                          'xRes': {'doc': 'Optional width of image to create. The minimal allowed value is 2. This parameter only applies to procedural textures. The dimension in X will be 128 by default, if a value less than 2 is specified. ',
                                                                   'type': 'int'},
                                                          'yRes': {'doc': 'Optional height of image to create. The minimal allowed value is 2. This parameter only applies to procedural textures. The dimension in Y will be 128 by default, if a value less than 2 is specified.',
                                                                   'type': 'int'}},
                                              'args': [('image',
                                                        'MImage',
                                                        'out'),
                                                       ('color',
                                                        'MColor',
                                                        'out'),
                                                       ('chan',
                                                        ('MMaterial',
                                                         'MtextureChannel'),
                                                        'in'),
                                                       ('mapped',
                                                        'bool',
                                                        'out'),
                                                       ('dagPath',
                                                        'MDagPath',
                                                        'in'),
                                                       ('xRes',
                                                        'int',
                                                        'in'),
                                                       ('yRes',
                                                        'int',
                                                        'in')],
                                              'defaults': {'xRes': -1,
                                                           'yRes': -1},
                                              'deprecated': False,
                                              'doc': '\r\nFor materials that have texture, this method will attempt to retrieve the pixel map for a given mapped channel of that material. If the channel is not mapped than a status of failure will be returned.',
                                              'inArgs': ['chan',
                                                         'dagPath',
                                                         'xRes',
                                                         'yRes'],
                                              'outArgs': ['image',
                                                          'color',
                                                          'mapped'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'chan': [],
                                                                 'color': ['&'],
                                                                 'dagPath': ['&'],
                                                                 'image': ['&'],
                                                                 'mapped': ['&'],
                                                                 'xRes': [],
                                                                 'yRes': []},
                                              'types': {'chan': ('MMaterial',
                                                                 'MtextureChannel'),
                                                        'color': 'MColor',
                                                        'dagPath': 'MDagPath',
                                                        'image': 'MImage',
                                                        'mapped': 'bool',
                                                        'xRes': 'int',
                                                        'yRes': 'int'}}]},
                'pymelEnums': {'MtextureChannel': "Enum('MtextureChannel', [('color', 0), ('kColor', 0), ('transparency', 1), ('kTransparency', 1), ('ambientColor', 2), ('kAmbientColor', 2), ('incandescence', 3), ('kIncandescence', 3), ('bumpMap', 4), ('kBumpMap', 4), ('diffuse', 5), ('kDiffuse', 5), ('transluscence', 6), ('kTransluscence', 6), ('roughness', 7), ('kRoughness', 7), ('highlightSize', 8), ('kHighlightSize', 8), ('whiteness', 9), ('kWhiteness', 9), ('cosinePower', 10), ('kCosinePower', 10), ('eccentricity', 11), ('kEccentricity', 11), ('specularRollOff', 12), ('kSpecularRollOff', 12), ('specularColor', 13), ('kSpecularColor', 13), ('reflectivity', 14), ('kReflectivity', 14), ('reflectedColor', 15), ('kReflectedColor', 15)], multiKeys=True)"}},
  'MMaterialArray': {'enums': {},
                     'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                     ('setLength', 'length')],
                     'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the indicated element. ',
                                                                 'qualifiers': [],
                                                                 'type': 'MMaterial'},
                                                  'returnType': 'MMaterial',
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned']},
                                                  'types': {'index': 'uint'}},
                                                 {'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                        'type': 'uint'}},
                                                  'args': [('index',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The value of the indicated element. ',
                                                                 'qualifiers': [],
                                                                 'type': 'MMaterial'},
                                                  'returnType': 'MMaterial',
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}],
                                 'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                     'type': 'MMaterial'}},
                                             'args': [('element',
                                                       'MMaterial',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                             'inArgs': ['element'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'element': ['const',
                                                                            '&']},
                                             'types': {'element': 'MMaterial'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nNO SCRIPT SUPPORT. \n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'clear': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                  'type': 'MMaterialArray'}},
                                           'args': [('source',
                                                     'MMaterialArray',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nCopy the contents of the source array to this array.',
                                           'inArgs': ['source'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'source': ['const',
                                                                         '&']},
                                           'types': {'source': 'MMaterialArray'}}],
                                 'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                     'type': 'MMaterial'},
                                                         'index': {'doc': 'the index of the element to set to the the new value',
                                                                   'type': 'uint'}},
                                             'args': [('element',
                                                       'MMaterial',
                                                       'in'),
                                                      ('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                             'inArgs': ['element',
                                                        'index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'element': ['const',
                                                                            '&'],
                                                                'index': ['unsigned']},
                                             'types': {'element': 'MMaterial',
                                                       'index': 'uint'}}],
                                 'length': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the number of elements in the instance.',
                                             'inArgs': [],
                                             'inverse': ('setLength',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                 'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                   'type': 'uint'}},
                                             'args': [('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                             'inArgs': ['index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'index': ['unsigned']},
                                             'types': {'index': 'uint'}}],
                                 'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                  'type': 'MMaterial'},
                                                      'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                                'type': 'uint'}},
                                          'args': [('element',
                                                    'MMaterial',
                                                    'in'),
                                                   ('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nSets the value of the indicated element to the indicated  MMaterial  value.',
                                          'inArgs': ['element', 'index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': ['const',
                                                                         '&'],
                                                             'index': ['unsigned']},
                                          'types': {'element': 'MMaterial',
                                                    'index': 'uint'}}],
                                 'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                       'type': 'uint'}},
                                                'args': [('length',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                                'inArgs': ['length'],
                                                'inverse': ('length',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'length': ['unsigned']},
                                                'types': {'length': 'uint'}}],
                                 'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                    'type': 'uint'}},
                                                       'args': [('newIncrement',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                       'inArgs': ['newIncrement'],
                                                       'inverse': ('sizeIncrement',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'newIncrement': ['unsigned']},
                                                       'types': {'newIncrement': 'uint'}}],
                                 'sizeIncrement': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                    'inArgs': [],
                                                    'inverse': ('setSizeIncrement',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'length': 'getLength',
                                      'sizeIncrement': 'getSizeIncrement'}},
  'MMatrix': {'enums': {},
              'methods': {'__add__': [{'argInfo': {'right': {'doc': 'Matrix to add to this one.',
                                                             'type': 'MMatrix'}},
                                       'args': [('right',
                                                 'MMatrix',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe matrix addition operator. Does not modify this matrix.',
                                       'inArgs': ['right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'New matrix containing the result. ',
                                                      'qualifiers': [],
                                                      'type': 'MMatrix'},
                                       'returnType': 'MMatrix',
                                       'static': False,
                                       'typeQualifiers': {'right': ['const',
                                                                    '&']},
                                       'types': {'right': 'MMatrix'}}],
                          '__eq__': [{'argInfo': {'other': {'doc': 'Matrix to compare against.',
                                                            'type': 'MMatrix'}},
                                      'args': [('other',
                                                'MMatrix',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe matrix equality operator. The matrices must be identical.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'True if other contains the same values as this matrix, false otherwise. ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MMatrix'}}],
                          '__getitem__': [{'argInfo': {'row': {'doc': 'index of the row to access',
                                                               'type': 'uint'}},
                                           'args': [('row',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nIndex operator. Returns an entire row of the matrix as an array of doubles.',
                                           'inArgs': ['row'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': ' double array containing the values of the specified row   ',
                                                          'qualifiers': ['*'],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {'row': ['unsigned']},
                                           'types': {'row': 'uint'}},
                                          {'argInfo': {'row': {'doc': 'index of the row to access',
                                                               'type': 'uint'}},
                                           'args': [('row',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['row'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': ' double array containing the values of the specified row   ',
                                                          'qualifiers': ['*'],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {'row': ['unsigned']},
                                           'types': {'row': 'uint'}}],
                          '__iadd__': [{'argInfo': {'right': {'doc': 'Matrix to add.',
                                                              'type': 'MMatrix'}},
                                        'args': [('right',
                                                  'MMatrix',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place matrix addition operator. Modifies this matrix.',
                                        'inArgs': ['right'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'This matrix. ',
                                                       'qualifiers': ['&'],
                                                       'type': 'MMatrix'},
                                        'returnType': 'MMatrix',
                                        'static': False,
                                        'typeQualifiers': {'right': ['const',
                                                                     '&']},
                                        'types': {'right': 'MMatrix'}}],
                          '__imul__': [{'argInfo': {'right': {'doc': 'Matrix to multiply this one by.',
                                                              'type': 'MMatrix'}},
                                        'args': [('right',
                                                  'MMatrix',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place matrix multiplication operator. Modifies this matrix.',
                                        'inArgs': ['right'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'This matrix. ',
                                                       'qualifiers': ['&'],
                                                       'type': 'MMatrix'},
                                        'returnType': 'MMatrix',
                                        'static': False,
                                        'typeQualifiers': {'right': ['const',
                                                                     '&']},
                                        'types': {'right': 'MMatrix'}},
                                       {'argInfo': {'factor': {'doc': 'Scalar to multiply this matrix by.',
                                                               'type': 'double'}},
                                        'args': [('factor',
                                                  'double',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place matrix multiply by a scalar operator. Modifies this matrix.',
                                        'inArgs': ['factor'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'This matrix. ',
                                                       'qualifiers': ['&'],
                                                       'type': 'MMatrix'},
                                        'returnType': 'MMatrix',
                                        'static': False,
                                        'typeQualifiers': {'factor': []},
                                        'types': {'factor': 'double'}}],
                          '__isub__': [{'argInfo': {'right': {'doc': 'Matrix to add to this one.',
                                                              'type': 'MMatrix'}},
                                        'args': [('right',
                                                  'MMatrix',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place matrix subtraction operator. Modifies this matrix.',
                                        'inArgs': ['right'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'This matrix. ',
                                                       'qualifiers': ['&'],
                                                       'type': 'MMatrix'},
                                        'returnType': 'MMatrix',
                                        'static': False,
                                        'typeQualifiers': {'right': ['const',
                                                                     '&']},
                                        'types': {'right': 'MMatrix'}}],
                          '__mul__': [{'argInfo': {'right': {'doc': 'Matrix to multiply this one by.',
                                                             'type': 'MMatrix'}},
                                       'args': [('right',
                                                 'MMatrix',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe matrix multiplication operator. Does not modify this matrix.',
                                       'inArgs': ['right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'New matrix containing the result. ',
                                                      'qualifiers': [],
                                                      'type': 'MMatrix'},
                                       'returnType': 'MMatrix',
                                       'static': False,
                                       'typeQualifiers': {'right': ['const',
                                                                    '&']},
                                       'types': {'right': 'MMatrix'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this matrix by.',
                                                              'type': 'double'}},
                                       'args': [('factor',
                                                 'double',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe matrix multiply by a scalar operator. Does not modify this matrix.',
                                       'inArgs': ['factor'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'New matrix containing the result. ',
                                                      'qualifiers': [],
                                                      'type': 'MMatrix'},
                                       'returnType': 'MMatrix',
                                       'static': False,
                                       'typeQualifiers': {'factor': []},
                                       'types': {'factor': 'double'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this matrix by. ',
                                                              'type': 'double'},
                                                   'right': {'doc': 'This matrix.',
                                                             'type': 'MMatrix'}},
                                       'args': [('factor',
                                                 'double',
                                                 'in'),
                                                ('right',
                                                 'MMatrix',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['factor', 'right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'New matrix containing the result. ',
                                                      'qualifiers': ['MMatrix'],
                                                      'type': ('MMatrix',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MMatrix',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'factor': [],
                                                          'right': ['const',
                                                                    '&']},
                                       'types': {'factor': 'double',
                                                 'right': 'MMatrix'}}],
                          '__ne__': [{'argInfo': {'other': {'doc': 'Matrix to compare against.',
                                                            'type': 'MMatrix'}},
                                      'args': [('other',
                                                'MMatrix',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe matrix inequality operator.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'False if other contains the same values as this matrix, true otherwise. ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MMatrix'}}],
                          '__sub__': [{'argInfo': {'right': {'doc': 'Matrix to subtract from this one.',
                                                             'type': 'MMatrix'}},
                                       'args': [('right',
                                                 'MMatrix',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe matrix subtraction operator. Does not modify this matrix.',
                                       'inArgs': ['right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'New matrix containing the result. ',
                                                      'qualifiers': [],
                                                      'type': 'MMatrix'},
                                       'returnType': 'MMatrix',
                                       'static': False,
                                       'typeQualifiers': {'right': ['const',
                                                                    '&']},
                                       'types': {'right': 'MMatrix'}}],
                          'adjoint': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCompute and return the adjoint of this instance.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MMatrix'},
                                       'returnType': 'MMatrix',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'det3x3': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nCompute and return the determinant of the upper left 3x3 submatrix of this instance',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                          'det4x4': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nCompute and return the determinant of this instance',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                          'get': [{'argInfo': {'dest': {'doc': '4x4 matrix of doubles to populate',
                                                        'type': 'double__array4'}},
                                   'args': [('dest',
                                             'double__array4',
                                             'out')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nFill a 4x4 matrix of doubles with the elements from the instance.',
                                   'inArgs': [],
                                   'outArgs': ['dest'],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': None},
                                   'returnType': None,
                                   'static': False,
                                   'typeQualifiers': {'dest': []},
                                   'types': {'dest': 'double__array4'}},
                                  {'argInfo': {'dest': {'doc': '4x4 matrix of floats to populate',
                                                        'type': 'float__array4'}},
                                   'args': [('dest',
                                             'float__array4',
                                             'out')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nFill a 4x4 matrix of floats with the elements from the instance.',
                                   'inArgs': [],
                                   'outArgs': ['dest'],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': None},
                                   'returnType': None,
                                   'static': False,
                                   'typeQualifiers': {'dest': []},
                                   'types': {'dest': 'float__array4'}}],
                          'homogenize': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nCompute and return a homogenized version of this instance.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'MMatrix'},
                                          'returnType': 'MMatrix',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'inverse': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCompute and return the inverse of this instance.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The inverted matrix ',
                                                      'qualifiers': [],
                                                      'type': 'MMatrix'},
                                       'returnType': 'MMatrix',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                          'isEquivalent': [{'argInfo': {'other': {'doc': 'the matrix to compare to ',
                                                                  'type': 'MMatrix'},
                                                        'tolerance': {'doc': 'the tolerance to use during the comparison',
                                                                      'type': 'double'}},
                                            'args': [('other',
                                                      'MMatrix',
                                                      'in'),
                                                     ('tolerance',
                                                      'double',
                                                      'in')],
                                            'defaults': {'tolerance': 1e-10},
                                            'deprecated': False,
                                            'doc': '\r\nDetermine if the given matrix is equivalent to this instance within the specified tolerance.',
                                            'inArgs': ['other',
                                                       'tolerance'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'True if the matrices are equivalent and false otherwise ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'tolerance': []},
                                            'types': {'other': 'MMatrix',
                                                      'tolerance': 'double'}}],
                          'isSingular': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nDetermines if the given matrix is singular.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'setToIdentity': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet this instance to the 4x4 identity matrix.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'This matrix. ',
                                                            'qualifiers': ['&'],
                                                            'type': 'MMatrix'},
                                             'returnType': 'MMatrix',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                          'setToProduct': [{'argInfo': {'left': {'doc': 'the left hand matrix for the operation ',
                                                                 'type': 'MMatrix'},
                                                        'right': {'doc': 'the right hand matrix for the operation',
                                                                  'type': 'MMatrix'}},
                                            'args': [('left',
                                                      'MMatrix',
                                                      'in'),
                                                     ('right',
                                                      'MMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet this instance to the inner product of the two argument matrices.',
                                            'inArgs': ['left', 'right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'This matrix. ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MMatrix'},
                                            'returnType': 'MMatrix',
                                            'static': False,
                                            'typeQualifiers': {'left': ['const',
                                                                        '&'],
                                                               'right': ['const',
                                                                         '&']},
                                            'types': {'left': 'MMatrix',
                                                      'right': 'MMatrix'}}],
                          'transpose': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nCompute and return the transpose of this instance.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The transposed matrix ',
                                                        'qualifiers': [],
                                                        'type': 'MMatrix'},
                                         'returnType': 'MMatrix',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
              'pymelEnums': {}},
  'MMatrixArray': {'enums': {},
                   'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                   ('setLength', 'length')],
                   'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The value of the indicated element. ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MMatrix'},
                                                'returnType': 'MMatrix',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}},
                                               {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nIndex operator allowing assignment to an element of the array. Returns a reference to the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MMatrix'},
                                                'returnType': 'MMatrix',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                   'type': 'MMatrix'}},
                                           'args': [('element',
                                                     'MMatrix',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': ['const',
                                                                          '&']},
                                           'types': {'element': 'MMatrix'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                'type': 'MMatrixArray'}},
                                         'args': [('source',
                                                   'MMatrixArray',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nCopy the contents of the source array to this array.',
                                         'inArgs': ['source'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'source': ['const',
                                                                       '&']},
                                         'types': {'source': 'MMatrixArray'}}],
                               'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                   'type': 'MMatrix'},
                                                       'index': {'doc': 'the index of the element to set to the the new value',
                                                                 'type': 'uint'}},
                                           'args': [('element',
                                                     'MMatrix',
                                                     'in'),
                                                    ('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element', 'index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': ['const',
                                                                          '&'],
                                                              'index': ['unsigned']},
                                           'types': {'element': 'MMatrix',
                                                     'index': 'uint'}}],
                               'length': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the number of elements in the instance.',
                                           'inArgs': [],
                                           'inverse': ('setLength',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned']},
                                           'types': {'index': 'uint'}}],
                               'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'MMatrix'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'MMatrix',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the value of the indicated element to the indicated  MMatrix  value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': ['const',
                                                                       '&'],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'MMatrix',
                                                  'index': 'uint'}}],
                               'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                     'type': 'uint'}},
                                              'args': [('length',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                              'inArgs': ['length'],
                                              'inverse': ('length', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'length': ['unsigned']},
                                              'types': {'length': 'uint'}}],
                               'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                  'type': 'uint'}},
                                                     'args': [('newIncrement',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                     'inArgs': ['newIncrement'],
                                                     'inverse': ('sizeIncrement',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'newIncrement': ['unsigned']},
                                                     'types': {'newIncrement': 'uint'}}],
                               'sizeIncrement': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                  'inArgs': [],
                                                  'inverse': ('setSizeIncrement',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'length': 'getLength',
                                    'sizeIncrement': 'getSizeIncrement'}},
  'MMeshIntersector': {'enums': {},
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'create': [{'argInfo': {'matrix': {'doc': 'specify the mapping to apply for transforming points that are specified in the getClosestPoint method into the object space of the mesh.',
                                                                      'type': 'MMatrix'},
                                                           'meshObject': {'doc': 'a kMesh or kMeshData object ',
                                                                          'type': 'MObject'}},
                                               'args': [('meshObject',
                                                         'MObject',
                                                         'in'),
                                                        ('matrix',
                                                         'MMatrix',
                                                         'in')],
                                               'defaults': {'matrix': 'MMatrix::identity'},
                                               'deprecated': False,
                                               'doc': '\r\nThis method creates the data required by the intersector. It is a heavy operation that should be called only when necessary.',
                                               'inArgs': ['meshObject',
                                                          'matrix'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'matrix': ['const',
                                                                             '&'],
                                                                  'meshObject': ['&']},
                                               'types': {'matrix': 'MMatrix',
                                                         'meshObject': 'MObject'}}],
                                   'getClosestPoint': [{'argInfo': {'maxDistance': {'doc': 'Maximum distance to consider in object space.',
                                                                                    'type': 'double'},
                                                                    'meshPoint': {'doc': 'Resulting closest point in object space. ',
                                                                                  'type': 'MPointOnMesh'},
                                                                    'point': {'doc': "Specifies the location for which to evaluate the closest point on the mesh. `point' is transformed using the matrix parameter passed to the create() method, so for example if your matrix maps world to object space, then `point' should be specified in world space. ",
                                                                              'type': 'MPoint'}},
                                                        'args': [('point',
                                                                  'MPoint',
                                                                  'in'),
                                                                 ('meshPoint',
                                                                  'MPointOnMesh',
                                                                  'out'),
                                                                 ('maxDistance',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {'maxDistance': 'DBL_MAX'},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis method finds the closest point. Information is returned in the meshPoint object.',
                                                        'inArgs': ['point',
                                                                   'maxDistance'],
                                                        'outArgs': ['meshPoint'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'maxDistance': [],
                                                                           'meshPoint': ['&'],
                                                                           'point': ['const',
                                                                                     '&']},
                                                        'types': {'maxDistance': 'double',
                                                                  'meshPoint': 'MPointOnMesh',
                                                                  'point': 'MPoint'}}],
                                   'isCreated': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method returns true if the intersector is created. False is return otherwise. \r\n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                       'pymelEnums': {}},
  'MMeshIsectAccelParams': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MMeshSmoothOptions': {'enums': {'BoundaryRule': {'valueDocs': {'creaseAll': 'Crease boundary edges & vertices with valence of exactly 2.',
                                                                  'creaseEdge': 'Crease boundary edges only.',
                                                                  'invalid': 'Invalid value.',
                                                                  'kCreaseAll': 'Crease boundary edges & vertices with valence of exactly 2.',
                                                                  'kCreaseEdge': 'Crease boundary edges only.',
                                                                  'kInvalid': 'Invalid value.',
                                                                  'kLast': 'Last enum value.',
                                                                  'kLegacy': 'Uses the legacy algorithm, which performed no creasing.',
                                                                  'last': 'Last enum value.',
                                                                  'legacy': 'Uses the legacy algorithm, which performed no creasing.'},
                                                    'values': "Enum('BoundaryRule', {'kInvalid': -1, 'kLegacy': 0, 'kCreaseAll': 1, 'kCreaseEdge': 2, 'kLast': 3})"},
                                   'OpenSubdivCreaseMethod': {'valueDocs': {'chaikin': 'Chaikin crease method.',
                                                                            'invalidCreaseMethod': 'Invalid value.',
                                                                            'kChaikin': 'Chaikin crease method.',
                                                                            'kInvalidCreaseMethod': 'Invalid value.',
                                                                            'kLastCreaseMethod': 'Last enum value.',
                                                                            'kNormal': 'Normal crease method.',
                                                                            'lastCreaseMethod': 'Last enum value.',
                                                                            'normal': 'Normal crease method.'},
                                                              'values': "Enum('OpenSubdivCreaseMethod', {'kInvalidCreaseMethod': -1, 'kNormal': 0, 'kChaikin': 1, 'kLastCreaseMethod': 2})"},
                                   'OpenSubdivVertexBoundary': {'valueDocs': {'alwaysSharp': 'Use legacy boundary rules.',
                                                                              'invalidBoundary': 'Invalid value.',
                                                                              'kAlwaysSharp': 'Use legacy boundary rules.',
                                                                              'kInvalidBoundary': 'Invalid value.',
                                                                              'kLastBoundary': 'Last enum value.',
                                                                              'kNone': 'None.',
                                                                              'kSharpEdges': "Don't smooth edges.",
                                                                              'kSharpEdgesAndCorners': "Don't smooth edges & corners.",
                                                                              'lastBoundary': 'Last enum value.',
                                                                              'none': 'None.',
                                                                              'sharpEdges': "Don't smooth edges.",
                                                                              'sharpEdgesAndCorners': "Don't smooth edges & corners."},
                                                                'values': "Enum('OpenSubdivVertexBoundary', {'kInvalidBoundary': -1, 'kNone': 0, 'kSharpEdgesAndCorners': 1, 'kSharpEdges': 2, 'kAlwaysSharp': 3, 'kLastBoundary': 4})"},
                                   'SubdivisionType': {'valueDocs': {'catmullClark': 'Maya Catmull-Clark.',
                                                                     'invalidSubdivision': 'Invalid value.',
                                                                     'kCatmullClark': 'Maya Catmull-Clark.',
                                                                     'kInvalidSubdivision': 'Invalid value.',
                                                                     'kLastSubdivision': 'Last enum value.',
                                                                     'kOpenSubdivCatmullClarkAdaptive': 'OpenSubdiv Adaptive.',
                                                                     'kOpenSubdivCatmullClarkUniform': 'OpenSubdiv Uniform.',
                                                                     'lastSubdivision': 'Last enum value.',
                                                                     'openSubdivCatmullClarkAdaptive': 'OpenSubdiv Adaptive.',
                                                                     'openSubdivCatmullClarkUniform': 'OpenSubdiv Uniform.'},
                                                       'values': "Enum('SubdivisionType', {'kInvalidSubdivision': -1, 'kCatmullClark': 0, 'kOpenSubdivCatmullClarkUniform': 2, 'kOpenSubdivCatmullClarkAdaptive': 3, 'kLastSubdivision': 4})"}},
                         'invertibles': [('setOpenSubdivFaceVaryingBoundary',
                                          'openSubdivFaceVaryingBoundary'),
                                         ('setOpenSubdivSmoothTriangles',
                                          'openSubdivSmoothTriangles'),
                                         ('setSmoothUVs', 'smoothUVs'),
                                         ('setKeepHardEdge',
                                          'keepHardEdge'),
                                         ('setSmoothness', 'smoothness'),
                                         ('setOpenSubdivVertexBoundary',
                                          'openSubdivVertexBoundary'),
                                         ('setDivisions', 'divisions'),
                                         ('setBoundaryRule',
                                          'boundaryRule'),
                                         ('setKeepBorderEdge',
                                          'keepBorderEdge'),
                                         ('setSubdivisionType',
                                          'subdivisionType'),
                                         ('setOpenSubdivCreaseMethod',
                                          'openSubdivCreaseMethod'),
                                         ('setPropEdgeHardness',
                                          'propEdgeHardness')],
                         'methods': {'boundaryRule': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the current value for the boundary rule. See  setBoundaryRule()  for more details.',
                                                       'inArgs': [],
                                                       'inverse': ('setBoundaryRule',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Boundary rule.',
                                                                      'qualifiers': [],
                                                                      'type': ('MMeshSmoothOptions',
                                                                               'BoundaryRule')},
                                                       'returnType': ('MMeshSmoothOptions',
                                                                      'BoundaryRule'),
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'divisions': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nRetrieves the level of smoothing these options specify to perform on the mesh.',
                                                    'inArgs': [],
                                                    'inverse': ('setDivisions',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The smoothing level',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                     'keepBorderEdge': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nRetrieves whether or not these options specify that border edges will not be smoothed',
                                                         'inArgs': [],
                                                         'inverse': ('setKeepBorderEdge',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'True if border edges will not be smoothed',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}],
                                     'keepHardEdge': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nRetrieves whether or not these options specify that hard edges will not be smoothed',
                                                       'inArgs': [],
                                                       'inverse': ('setKeepHardEdge',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'True if hard edges will not be smoothed',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                     'openSubdivCreaseMethod': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nReturns the current OpenSubdiv crease method. See  setOpenSubdivCreaseMethod()  for more details.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setOpenSubdivCreaseMethod',
                                                                             False),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Crease method.',
                                                                                'qualifiers': [],
                                                                                'type': ('MMeshSmoothOptions',
                                                                                         'OpenSubdivCreaseMethod')},
                                                                 'returnType': ('MMeshSmoothOptions',
                                                                                'OpenSubdivCreaseMethod'),
                                                                 'static': False,
                                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                                 'types': {}}],
                                     'openSubdivFaceVaryingBoundary': [{'argInfo': {},
                                                                        'args': [],
                                                                        'defaults': {},
                                                                        'deprecated': False,
                                                                        'doc': '\nReturns the current value for the face varing (UV) boundary rule. See  setOpenSubdivFaceVaryingBoundary()  for more details.',
                                                                        'inArgs': [],
                                                                        'inverse': ('setOpenSubdivFaceVaryingBoundary',
                                                                                    False),
                                                                        'outArgs': [],
                                                                        'returnInfo': {'doc': 'UV Smoothing.',
                                                                                       'qualifiers': [],
                                                                                       'type': ('MMeshSmoothOptions',
                                                                                                'OpenSubdivVertexBoundary')},
                                                                        'returnType': ('MMeshSmoothOptions',
                                                                                       'OpenSubdivVertexBoundary'),
                                                                        'static': False,
                                                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                                                        'types': {}}],
                                     'openSubdivSmoothTriangles': [{'argInfo': {},
                                                                    'args': [],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\nRetrieves whether or not smooth triangles is enabled.',
                                                                    'inArgs': [],
                                                                    'inverse': ('setOpenSubdivSmoothTriangles',
                                                                                False),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'True if smooth triangles is enabled.',
                                                                                   'qualifiers': [],
                                                                                   'type': 'bool'},
                                                                    'returnType': 'bool',
                                                                    'static': False,
                                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                                    'types': {}}],
                                     'openSubdivVertexBoundary': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nReturns the current value for the vertex boundary rule. See  setOpenSubdivVertexBoundary()  for more details.',
                                                                   'inArgs': [],
                                                                   'inverse': ('setOpenSubdivVertexBoundary',
                                                                               False),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'Vertex Boundary.',
                                                                                  'qualifiers': [],
                                                                                  'type': ('MMeshSmoothOptions',
                                                                                           'OpenSubdivVertexBoundary')},
                                                                   'returnType': ('MMeshSmoothOptions',
                                                                                  'OpenSubdivVertexBoundary'),
                                                                   'static': False,
                                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                                   'types': {}}],
                                     'propEdgeHardness': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nRetrieves whether or not these options specify that the smooth mesh edges which are a result of edges from the base cage will share the same hardness value.',
                                                           'inArgs': [],
                                                           'inverse': ('setPropEdgeHardness',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'True if smooth edges share hardness with the base cage',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                     'setBoundaryRule': [{'argInfo': {'rule': {'doc': 'to apply ',
                                                                               'type': ('MMeshSmoothOptions',
                                                                                        'BoundaryRule')}},
                                                          'args': [('rule',
                                                                    ('MMeshSmoothOptions',
                                                                     'BoundaryRule'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSet the rule used to determine how boundary edges and vertices are creased. By default, creases are automatically applied to all boundary edges and all vertices that have only 2 incident edges prior to being converted to a smooth mesh.',
                                                          'inArgs': ['rule'],
                                                          'inverse': ('boundaryRule',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'rule': []},
                                                          'types': {'rule': ('MMeshSmoothOptions',
                                                                             'BoundaryRule')}}],
                                     'setDivisions': [{'argInfo': {'numDivisions': {'doc': 'Number of divisions. ',
                                                                                    'type': 'int'}},
                                                       'args': [('numDivisions',
                                                                 'int',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets the number of divisions stored in this options object.',
                                                       'inArgs': ['numDivisions'],
                                                       'inverse': ('divisions',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'numDivisions': []},
                                                       'types': {'numDivisions': 'int'}}],
                                     'setKeepBorderEdge': [{'argInfo': {'keepBorderEdge': {'doc': 'True if border edges should not be smoothed ',
                                                                                           'type': 'bool'}},
                                                            'args': [('keepBorderEdge',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSets whether or not these options specify that border edges will not be smoothed',
                                                            'inArgs': ['keepBorderEdge'],
                                                            'inverse': ('keepBorderEdge',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'keepBorderEdge': []},
                                                            'types': {'keepBorderEdge': 'bool'}}],
                                     'setKeepHardEdge': [{'argInfo': {'keepHardEdge': {'doc': 'True if hard edges should not be smoothed ',
                                                                                       'type': 'bool'}},
                                                          'args': [('keepHardEdge',
                                                                    'bool',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets whether or not these options specify that hard edges will not be smoothed',
                                                          'inArgs': ['keepHardEdge'],
                                                          'inverse': ('keepHardEdge',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'keepHardEdge': []},
                                                          'types': {'keepHardEdge': 'bool'}}],
                                     'setOpenSubdivCreaseMethod': [{'argInfo': {'method': {'doc': 'to apply ',
                                                                                           'type': ('MMeshSmoothOptions',
                                                                                                    'OpenSubdivCreaseMethod')}},
                                                                    'args': [('method',
                                                                              ('MMeshSmoothOptions',
                                                                               'OpenSubdivCreaseMethod'),
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\nSet the OpenSubdiv crease method.',
                                                                    'inArgs': ['method'],
                                                                    'inverse': ('openSubdivCreaseMethod',
                                                                                True),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                       'method': []},
                                                                    'types': {'method': ('MMeshSmoothOptions',
                                                                                         'OpenSubdivCreaseMethod')}}],
                                     'setOpenSubdivFaceVaryingBoundary': [{'argInfo': {'rule': {'doc': 'to apply ',
                                                                                                'type': ('MMeshSmoothOptions',
                                                                                                         'OpenSubdivVertexBoundary')}},
                                                                           'args': [('rule',
                                                                                     ('MMeshSmoothOptions',
                                                                                      'OpenSubdivVertexBoundary'),
                                                                                     'in')],
                                                                           'defaults': {},
                                                                           'deprecated': False,
                                                                           'doc': '\nSet the boundary rule used to determine how face varying data is interpolated. Specifically this determines how UVs are smoothed by OpenSubdiv becease UVs are treated as face varying data.',
                                                                           'inArgs': ['rule'],
                                                                           'inverse': ('openSubdivFaceVaryingBoundary',
                                                                                       True),
                                                                           'outArgs': [],
                                                                           'returnInfo': {'doc': '',
                                                                                          'qualifiers': [],
                                                                                          'type': None},
                                                                           'returnType': None,
                                                                           'static': False,
                                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                              'rule': []},
                                                                           'types': {'rule': ('MMeshSmoothOptions',
                                                                                              'OpenSubdivVertexBoundary')}}],
                                     'setOpenSubdivSmoothTriangles': [{'argInfo': {'smoothTriangles': {'doc': 'True if smooth triangles is to be enabled. ',
                                                                                                       'type': 'bool'}},
                                                                       'args': [('smoothTriangles',
                                                                                 'bool',
                                                                                 'in')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\nSets whether or not "smooth triangles" is enabled.',
                                                                       'inArgs': ['smoothTriangles'],
                                                                       'inverse': ('openSubdivSmoothTriangles',
                                                                                   True),
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                          'smoothTriangles': []},
                                                                       'types': {'smoothTriangles': 'bool'}}],
                                     'setOpenSubdivVertexBoundary': [{'argInfo': {'rule': {'doc': 'to apply ',
                                                                                           'type': ('MMeshSmoothOptions',
                                                                                                    'OpenSubdivVertexBoundary')}},
                                                                      'args': [('rule',
                                                                                ('MMeshSmoothOptions',
                                                                                 'OpenSubdivVertexBoundary'),
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\nSet the rule used to determine how boundary edges and vertices are creased.',
                                                                      'inArgs': ['rule'],
                                                                      'inverse': ('openSubdivVertexBoundary',
                                                                                  True),
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': None},
                                                                      'returnType': None,
                                                                      'static': False,
                                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                         'rule': []},
                                                                      'types': {'rule': ('MMeshSmoothOptions',
                                                                                         'OpenSubdivVertexBoundary')}}],
                                     'setPropEdgeHardness': [{'argInfo': {'propEdgeHardness': {'doc': 'True if smooth edges should share hardness with the base cage ',
                                                                                               'type': 'bool'}},
                                                              'args': [('propEdgeHardness',
                                                                        'bool',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets whether or not these options specify that smooth mesh edges which are a result of edges from the base cage will share the hardness value',
                                                              'inArgs': ['propEdgeHardness'],
                                                              'inverse': ('propEdgeHardness',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'propEdgeHardness': []},
                                                              'types': {'propEdgeHardness': 'bool'}}],
                                     'setSmoothUVs': [{'argInfo': {'smoothUVs': {'doc': 'True if UVs should be smoothed ',
                                                                                 'type': 'bool'}},
                                                       'args': [('smoothUVs',
                                                                 'bool',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSets whether or not these options specify to smooth UVs as well as geometry.',
                                                       'inArgs': ['smoothUVs'],
                                                       'inverse': ('smoothUVs',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'smoothUVs': []},
                                                       'types': {'smoothUVs': 'bool'}}],
                                     'setSmoothness': [{'argInfo': {'smoothness': {'doc': 'The smoothness ',
                                                                                   'type': 'float'}},
                                                        'args': [('smoothness',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the the smoothness parameter for this set of smooth options which has range [0,1] where 1 smooths the faces as much as possible',
                                                        'inArgs': ['smoothness'],
                                                        'inverse': ('smoothness',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'smoothness': []},
                                                        'types': {'smoothness': 'float'}}],
                                     'setSubdivisionType': [{'argInfo': {'subdivision': {'doc': 'algorithm to use ',
                                                                                         'type': ('MMeshSmoothOptions',
                                                                                                  'SubdivisionType')}},
                                                             'args': [('subdivision',
                                                                       ('MMeshSmoothOptions',
                                                                        'SubdivisionType'),
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nSet the subdivision algorithm used to control mesh smoothing. The default subdivision algorithm is Maya Catmull-Clark.',
                                                             'inArgs': ['subdivision'],
                                                             'inverse': ('subdivisionType',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'subdivision': []},
                                                             'types': {'subdivision': ('MMeshSmoothOptions',
                                                                                       'SubdivisionType')}}],
                                     'smoothUVs': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nRetrieves whether or not these options specify to smooth UVs as well as geometry.',
                                                    'inArgs': [],
                                                    'inverse': ('setSmoothUVs',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True if UVs are set to be smoothed',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                     'smoothness': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieves the smoothness parameter for this set of smooth options which has range [0,1] where 1 smooths the faces as much as possible',
                                                     'inArgs': [],
                                                     'inverse': ('setSmoothness',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The smoothness parameter',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                     'subdivisionType': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nReturns the current value for the subdivision type. See  setSubdivisionType()  for more details.',
                                                          'inArgs': [],
                                                          'inverse': ('setSubdivisionType',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Subdivision type.',
                                                                         'qualifiers': [],
                                                                         'type': ('MMeshSmoothOptions',
                                                                                  'SubdivisionType')},
                                                          'returnType': ('MMeshSmoothOptions',
                                                                         'SubdivisionType'),
                                                          'static': False,
                                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                                          'types': {}}]},
                         'pymelEnums': {'BoundaryRule': "Enum('BoundaryRule', [('invalid', -1), ('kInvalid', -1), ('legacy', 0), ('kLegacy', 0), ('creaseAll', 1), ('kCreaseAll', 1), ('creaseEdge', 2), ('kCreaseEdge', 2), ('last', 3), ('kLast', 3)], multiKeys=True)",
                                        'OpenSubdivCreaseMethod': "Enum('OpenSubdivCreaseMethod', [('invalidCreaseMethod', -1), ('kInvalidCreaseMethod', -1), ('normal', 0), ('kNormal', 0), ('chaikin', 1), ('kChaikin', 1), ('lastCreaseMethod', 2), ('kLastCreaseMethod', 2)], multiKeys=True)",
                                        'OpenSubdivVertexBoundary': "Enum('OpenSubdivVertexBoundary', [('invalidBoundary', -1), ('kInvalidBoundary', -1), ('none', 0), ('kNone', 0), ('sharpEdgesAndCorners', 1), ('kSharpEdgesAndCorners', 1), ('sharpEdges', 2), ('kSharpEdges', 2), ('alwaysSharp', 3), ('kAlwaysSharp', 3), ('lastBoundary', 4), ('kLastBoundary', 4)], multiKeys=True)",
                                        'SubdivisionType': "Enum('SubdivisionType', [('invalidSubdivision', -1), ('kInvalidSubdivision', -1), ('catmullClark', 0), ('kCatmullClark', 0), ('openSubdivCatmullClarkUniform', 2), ('kOpenSubdivCatmullClarkUniform', 2), ('openSubdivCatmullClarkAdaptive', 3), ('kOpenSubdivCatmullClarkAdaptive', 3), ('lastSubdivision', 4), ('kLastSubdivision', 4)], multiKeys=True)"},
                         'pymelMethods': {'boundaryRule': 'getBoundaryRule',
                                          'divisions': 'getDivisions',
                                          'keepBorderEdge': 'getKeepBorderEdge',
                                          'keepHardEdge': 'getKeepHardEdge',
                                          'openSubdivCreaseMethod': 'getOpenSubdivCreaseMethod',
                                          'openSubdivFaceVaryingBoundary': 'getOpenSubdivFaceVaryingBoundary',
                                          'openSubdivSmoothTriangles': 'getOpenSubdivSmoothTriangles',
                                          'openSubdivVertexBoundary': 'getOpenSubdivVertexBoundary',
                                          'propEdgeHardness': 'getPropEdgeHardness',
                                          'smoothUVs': 'getSmoothUVs',
                                          'smoothness': 'getSmoothness',
                                          'subdivisionType': 'getSubdivisionType'}},
  'MMessage': {'enums': {'Action': {'valueDocs': {'defaultAction': 'do the action or not, whatever is the default',
                                                  'doAction': 'do the action',
                                                  'doNotDoAction': 'do not do the action',
                                                  'kDefaultAction': 'do the action or not, whatever is the default',
                                                  'kDoAction': 'do the action',
                                                  'kDoNotDoAction': 'do not do the action'},
                                    'values': "Enum('Action', {'kDefaultAction': 0, 'kDoNotDoAction': 1, 'kDoAction': 2})"}},
               'methods': {'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'currentCallbackId': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the callback ID of the currently executing callback. If called outside of a callback, an invalid MCallbackId and failed status will be returned.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Callback ID of currently executing callback',
                                                                 'qualifiers': [],
                                                                 'type': 'MCallbackId'},
                                                  'returnType': 'MCallbackId',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                           'nodeCallbacks': [{'argInfo': {'ids': {'doc': 'MCallbackId array to store the list of callback IDs.',
                                                                  'type': 'MCallbackIdArray'},
                                                          'node': {'doc': 'Node to query for callbacks. ',
                                                                   'type': 'MObject'}},
                                              'args': [('node',
                                                        'MObject',
                                                        'in'),
                                                       ('ids',
                                                        'MCallbackIdArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns a list of callback IDs associated registered to a given node.',
                                              'inArgs': ['node'],
                                              'outArgs': ['ids'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'ids': ['&'],
                                                                 'node': ['&']},
                                              'types': {'ids': 'MCallbackIdArray',
                                                        'node': 'MObject'}}],
                           'registeringCallableScript': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturn true if this  MMessage  object has its callbacks defined in script. \r\n',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': True,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                           'registeringCallableScriptNewAPI': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\r\nReturn true if this  MMessage  object has its callbacks defined in new Python API script. \r\n',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': 'bool'},
                                                                'returnType': 'bool',
                                                                'static': True,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                           'removeCallback': [{'argInfo': {'id': {'doc': 'identifier of callback to be removed',
                                                                  'type': 'MCallbackId'}},
                                               'args': [('id',
                                                         'MCallbackId',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nRemove the specified callback from maya.',
                                               'inArgs': ['id'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'id': []},
                                               'types': {'id': 'MCallbackId'}}],
                           'removeCallbacks': [{'argInfo': {'idList': {'doc': 'identifier list of callbacks to be removed',
                                                                       'type': 'MCallbackIdArray'}},
                                                'args': [('idList',
                                                          'MCallbackIdArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nRemove all of the specified callbacks from maya. \r\n',
                                                'inArgs': ['idList'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'idList': ['&']},
                                                'types': {'idList': 'MCallbackIdArray'}}],
                           'setRegisteringCallableScript': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nMark this  MMessage  object as one that will be passed callbacks defined in script. \r\n',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                           'setRegisteringCallableScriptNewAPI': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nMark this  MMessage  object as one that will be passed callbacks defined in new Python API script. \r\n',
                                                                   'inArgs': [],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': True,
                                                                   'typeQualifiers': {},
                                                                   'types': {}}]},
               'pymelEnums': {'Action': "Enum('Action', [('defaultAction', 0), ('kDefaultAction', 0), ('doNotDoAction', 1), ('kDoNotDoAction', 1), ('doAction', 2), ('kDoAction', 2)], multiKeys=True)"},
               'pymelMethods': {'registeringCallableScript': 'getRegisteringCallableScript',
                                'registeringCallableScriptNewAPI': 'getRegisteringCallableScriptNewAPI'}},
  'MModelMessage': {'enums': {'Message': {'valueDocs': {'kActiveListModified': 'active selection changes'},
                                          'values': "Enum('Message', {'kActiveListModified': 0})"}},
                    'methods': {'addAfterDuplicateCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                          'type': 'void'},
                                                                           'func': {'doc': 'the callback function',
                                                                                    'type': ('MMessage',
                                                                                             'MBasicFunction')}},
                                                               'args': [('func',
                                                                         ('MMessage',
                                                                          'MBasicFunction'),
                                                                         'in'),
                                                                        ('clientData',
                                                                         'void',
                                                                         'in')],
                                                               'defaults': {'clientData': None},
                                                               'deprecated': False,
                                                               'doc': '\r\nAfter duplicate callback. \r\n',
                                                               'inArgs': ['func',
                                                                          'clientData'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                              'qualifiers': [],
                                                                              'type': 'MCallbackId'},
                                                               'returnType': 'MCallbackId',
                                                               'static': True,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'clientData': ['*'],
                                                                                  'func': []},
                                                               'types': {'clientData': 'void',
                                                                         'func': ('MMessage',
                                                                                  'MBasicFunction')}}],
                                'addBeforeDuplicateCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                           'type': 'void'},
                                                                            'func': {'doc': 'the callback function',
                                                                                     'type': ('MMessage',
                                                                                              'MBasicFunction')}},
                                                                'args': [('func',
                                                                          ('MMessage',
                                                                           'MBasicFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': '\r\nBefore duplicate callback. \r\n',
                                                                'inArgs': ['func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'func': []},
                                                                'types': {'clientData': 'void',
                                                                          'func': ('MMessage',
                                                                                   'MBasicFunction')}}],
                                'addCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                            'type': 'void'},
                                                             'func': {'doc': 'the callback function',
                                                                      'type': ('MMessage',
                                                                               'MBasicFunction')},
                                                             'msg': {'doc': 'the model message that will trigger the callback ',
                                                                     'type': ('MModelMessage',
                                                                              'Message')}},
                                                 'args': [('msg',
                                                           ('MModelMessage',
                                                            'Message'),
                                                           'in'),
                                                          ('func',
                                                           ('MMessage',
                                                            'MBasicFunction'),
                                                           'in'),
                                                          ('clientData',
                                                           'void',
                                                           'in')],
                                                 'defaults': {'clientData': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdds a new callback for the specified model message.',
                                                 'inArgs': ['msg',
                                                            'func',
                                                            'clientData'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                'qualifiers': [],
                                                                'type': 'MCallbackId'},
                                                 'returnType': 'MCallbackId',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'clientData': ['*'],
                                                                    'func': [],
                                                                    'msg': []},
                                                 'types': {'clientData': 'void',
                                                           'func': ('MMessage',
                                                                    'MBasicFunction'),
                                                           'msg': ('MModelMessage',
                                                                   'Message')}}],
                                'addNodeAddedToModelCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                            'type': 'void'},
                                                                             'dagNode': {'doc': 'Node that should acquire the callback ',
                                                                                         'type': 'MObject'},
                                                                             'func': {'doc': 'the callback function',
                                                                                      'type': ('MMessage',
                                                                                               'MNodeFunction')}},
                                                                 'args': [('dagNode',
                                                                           'MObject',
                                                                           'in'),
                                                                          ('func',
                                                                           ('MMessage',
                                                                            'MNodeFunction'),
                                                                           'in'),
                                                                          ('clientData',
                                                                           'void',
                                                                           'in')],
                                                                 'defaults': {'clientData': None},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nNode added to model message. \r\n',
                                                                 'inArgs': ['dagNode',
                                                                            'func',
                                                                            'clientData'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                'qualifiers': [],
                                                                                'type': 'MCallbackId'},
                                                                 'returnType': 'MCallbackId',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'clientData': ['*'],
                                                                                    'dagNode': ['const',
                                                                                                '&'],
                                                                                    'func': []},
                                                                 'types': {'clientData': 'void',
                                                                           'dagNode': 'MObject',
                                                                           'func': ('MMessage',
                                                                                    'MNodeFunction')}}],
                                'addNodeRemovedFromModelCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                                'type': 'void'},
                                                                                 'dagNode': {'doc': 'Node that should acquire the callback ',
                                                                                             'type': 'MObject'},
                                                                                 'func': {'doc': 'the callback function',
                                                                                          'type': ('MMessage',
                                                                                                   'MNodeFunction')}},
                                                                     'args': [('dagNode',
                                                                               'MObject',
                                                                               'in'),
                                                                              ('func',
                                                                               ('MMessage',
                                                                                'MNodeFunction'),
                                                                               'in'),
                                                                              ('clientData',
                                                                               'void',
                                                                               'in')],
                                                                     'defaults': {'clientData': None},
                                                                     'deprecated': False,
                                                                     'doc': '\r\nNode removed from model message. \r\n',
                                                                     'inArgs': ['dagNode',
                                                                                'func',
                                                                                'clientData'],
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                    'qualifiers': [],
                                                                                    'type': 'MCallbackId'},
                                                                     'returnType': 'MCallbackId',
                                                                     'static': True,
                                                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                        'clientData': ['*'],
                                                                                        'dagNode': ['const',
                                                                                                    '&'],
                                                                                        'func': []},
                                                                     'types': {'clientData': 'void',
                                                                               'dagNode': 'MObject',
                                                                               'func': ('MMessage',
                                                                                        'MNodeFunction')}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                    'pymelEnums': {'Message': "Enum('Message', {'kActiveListModified': 0})"}},
  'MNamespace': {'enums': {},
                 'invertibles': [('setCurrentNamespace',
                                  'currentNamespace'),
                                 ('setRelativeNames', 'relativeNames')],
                 'methods': {'addNamespace': [{'argInfo': {'name': {'doc': 'The new namespace to create. A qualified or unqualified name may be used. If a qualified name is used and one or more of the higher level namespaces do not already exist, they will be created automatically. For example, if the new name is "a:b:c" and "a" does not yet exist, then it will be created automatically and "b" automatically created beneath it and finally "c" will be created beneath "b". If the supplied name contains invalid characters it will first be modified as per the validateName() method. ',
                                                                    'type': 'MString'},
                                                           'parent': {'doc': 'The fully qualified name of the namespace under which the new one is to be created. If not provided then the current namespace will be used. If the name of the new namespace is absolute (i.e. begins with a colon, ":a:b:c") then the \'parent\' parameter will be ignored and the new namespace will be created under the root namespace.',
                                                                      'type': 'MString'}},
                                               'args': [('name',
                                                         'MString',
                                                         'in'),
                                                        ('parent',
                                                         'MString',
                                                         'in')],
                                               'defaults': {'parent': None},
                                               'deprecated': False,
                                               'doc': "\r\nCreate the namespace `name'. If the `parent' namespace is given the new namespace will be a child of `parent', otherwise the new namespace will be a child of the current namespace. The new namespace is added, but not made current. To make the new namespace be current use  MNamespace::setCurrentNamespace() . Note that adding a namespace changes the scene, so any code that calls this method needs to handle undo.",
                                               'inArgs': ['name',
                                                          'parent'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'name': ['const',
                                                                           '&'],
                                                                  'parent': ['const',
                                                                             '*']},
                                               'types': {'name': 'MString',
                                                         'parent': 'MString'}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'currentNamespace': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the name of the current namespace. This name is returned as an absolute namepath (i.e. fully qualfied from the root namespace downwards, ":a:b:c").',
                                                   'inArgs': [],
                                                   'inverse': ('setCurrentNamespace',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The name of the current namespace as an absolute namepath. ',
                                                                  'qualifiers': [],
                                                                  'type': 'MString'},
                                                   'returnType': 'MString',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                             'getNamespaceFromName': [{'argInfo': {'fullName': {'doc': 'the full name. ',
                                                                                'type': 'MString'}},
                                                       'args': [('fullName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGet namespace from a full name. For example, given a full name: "a:b:c:d:ball" this method would return: "a:b:c:d".',
                                                       'inArgs': ['fullName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Returns the namespace from the full name.',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'fullName': ['const',
                                                                                       '&']},
                                                       'types': {'fullName': 'MString'}}],
                             'getNamespaceObjects': [{'argInfo': {'parentNamespace': {'doc': 'namepath of namespace to query. ',
                                                                                      'type': 'MString'},
                                                                  'recurse': {'doc': "Optional parameter to control whether objects within all descendant namespaces should be returned, or only objects within the specified namespace `parentNamespace' should be returned. \r  False (the default if unspecified): only objects within `parentNamespace' are listed. \r  True: objects within all descendant namespaces are listed. ",
                                                                              'type': 'bool'}},
                                                      'args': [('parentNamespace',
                                                                'MString',
                                                                'in'),
                                                               ('recurse',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {'recurse': False},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturn an array of MObjects representing the object contained within the specified namespace. To query the current namespace, call this method in this way:',
                                                      'inArgs': ['parentNamespace',
                                                                 'recurse'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': "The list of objects that belong to the namespace specified by the 'parentNamespace' parameter. If the 'recurse' parameter was also specified as true, the list will contain the objects belonging to any child namespaces.",
                                                                     'qualifiers': [],
                                                                     'type': 'MObjectArray'},
                                                      'returnType': 'MObjectArray',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'parentNamespace': ['const',
                                                                                             '&'],
                                                                         'recurse': ['const']},
                                                      'types': {'parentNamespace': 'MString',
                                                                'recurse': 'bool'}}],
                             'getNamespaces': [{'argInfo': {'recurse': {'doc': 'optional parameter to control whether all namespaces or just top-level namespaces are returned. A value of false (the default if unspecified) causes only the top-level namespaces to be returned. If true, all namespaces will be listed. ',
                                                                        'type': 'bool'}},
                                                'args': [('recurse',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'recurse': False},
                                                'deprecated': False,
                                                'doc': '\r\nReturn a list of all namespaces in the current namespace.',
                                                'inArgs': ['recurse'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The list of namespaces in the current namespace.',
                                                               'qualifiers': [],
                                                               'type': 'MStringArray'},
                                                'returnType': 'MStringArray',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'recurse': ['const']},
                                                'types': {'recurse': 'bool'}},
                                               {'argInfo': {'parentNamespace': {'doc': 'the namespace to query. ',
                                                                                'type': 'MString'},
                                                            'recurse': {'doc': "optional parameter to control whether all descendents or just the direct children are returned. A value of false (the default if unspecified) causes only the direct children of `parentNamespace' to be listed. A value of true causes all descendent namespaces to be returned. ",
                                                                        'type': 'bool'}},
                                                'args': [('parentNamespace',
                                                          'MString',
                                                          'in'),
                                                         ('recurse',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'recurse': False},
                                                'deprecated': False,
                                                'doc': "\r\nReturn a list of all child namespaces of `parentNamespace', with the option to list only direct children versus all descendents. To list ALL namespaces in Maya, from the root downwards, specify the root namespace, i.e.:",
                                                'inArgs': ['parentNamespace',
                                                           'recurse'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': "The list of namespaces in the namespace specified via the 'namespacesToQuery' parameter.",
                                                               'qualifiers': [],
                                                               'type': 'MStringArray'},
                                                'returnType': 'MStringArray',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                   'parentNamespace': ['const',
                                                                                       '&'],
                                                                   'recurse': ['const']},
                                                'types': {'parentNamespace': 'MString',
                                                          'recurse': 'bool'}}],
                             'makeNamepathAbsolute': [{'argInfo': {'namepath': {'doc': 'the root-relative namepath. ',
                                                                                'type': 'MString'}},
                                                       'args': [('namepath',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nMake a namepath which is relative to the root into an absolute namepath. For example, given the namepath "a:sphere" this method returns ":a:sphere". It also culls out duplicate and trailing separators, e.g. "a:b::c:" will return ":a:b:c".',
                                                       'inArgs': ['namepath'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The absolute namepath.',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'namepath': ['const',
                                                                                       '&']},
                                                       'types': {'namepath': 'MString'}}],
                             'moveNamespace': [{'argInfo': {'dst': {'doc': 'destination namespace to which objects will be moved. ',
                                                                    'type': 'MString'},
                                                            'force': {'doc': 'optional parameter which if true forces the move even if name clashes occur, in which case nodes are renamed to ensure uniqueness. If false, the move will not happen if there are clashes. The default value is false.',
                                                                      'type': 'bool'},
                                                            'src': {'doc': 'source namespace from which objects will be moved. ',
                                                                    'type': 'MString'}},
                                                'args': [('src',
                                                          'MString',
                                                          'in'),
                                                         ('dst',
                                                          'MString',
                                                          'in'),
                                                         ('force',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'force': False},
                                                'deprecated': False,
                                                'doc': "\r\nMove the contents of the namespace `src' into the namespace `dst'. Note that moving namespace contents changes the scene, so any code that calls this method needs to handle undo.",
                                                'inArgs': ['src',
                                                           'dst',
                                                           'force'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'dst': ['const',
                                                                           '&'],
                                                                   'force': ['const'],
                                                                   'src': ['const',
                                                                           '&']},
                                                'types': {'dst': 'MString',
                                                          'force': 'bool',
                                                          'src': 'MString'}}],
                             'namespaceExists': [{'argInfo': {'name': {'doc': 'the name of the namespace to search for. ',
                                                                       'type': 'MString'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nCheck if a given namespace exists.',
                                                  'inArgs': ['name'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' true the namespace with the given name exists.  false the namespace with the given name does not exist.   ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'name': ['const',
                                                                              '&']},
                                                  'types': {'name': 'MString'}}],
                             'parentNamespace': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the name of the current namespace\'s parent. This name is returned as an absolute namepath (i.e. fully qualfied from the root namespace downwards, ":a:b"). If the root namespace is current, this method returns an error.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': "The name of the current namespace's parent as an absolute namepath. ",
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                             'relativeNames': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nQuery Maya\'s current "relative name lookup" state. Relative name lookup causes lookups to be relative to the current namespace. By default, relative name lookup in Maya is off, which causes name lookups to be relative to the root namespace. For example, if you have the object :a:b:sphere, and the current namespace is ":a:b", in relative name lookup mode you can issue a command like',
                                                'inArgs': [],
                                                'inverse': ('setRelativeNames',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true if relatve name lookup is on, false otherwise.',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                             'removeNamespace': [{'argInfo': {'name': {'doc': 'specifies the namespace to remove. ',
                                                                       'type': 'MString'},
                                                              'removeContents': {'doc': 'detemine if remove contents of namespace',
                                                                                 'type': 'bool'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in'),
                                                           ('removeContents',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {'removeContents': False},
                                                  'deprecated': False,
                                                  'doc': '\r\nRemove the specified namespace. Note that removing a namespace changes the scene, so any code that calls this method needs to handle undo.',
                                                  'inArgs': ['name',
                                                             'removeContents'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {'name': ['const',
                                                                              '&'],
                                                                     'removeContents': []},
                                                  'types': {'name': 'MString',
                                                            'removeContents': 'bool'}}],
                             'renameNamespace': [{'argInfo': {'newName': {'doc': 'the new name for the namespace. If the supplied name contains invalid characters it will first be modified as per the validateName() method. ',
                                                                          'type': 'MString'},
                                                              'oldName': {'doc': 'the name of the namespace to rename. ',
                                                                          'type': 'MString'},
                                                              'parent': {'doc': 'optionally provides the name of the new parent.',
                                                                         'type': 'MString'}},
                                                  'args': [('oldName',
                                                            'MString',
                                                            'in'),
                                                           ('newName',
                                                            'MString',
                                                            'in'),
                                                           ('parent',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {'parent': None},
                                                  'deprecated': False,
                                                  'doc': '\r\nRename the specified namespace to a new name with optional parent name. Note that removing a namespace changes the scene, so any code that calls this method needs to handle undo.',
                                                  'inArgs': ['oldName',
                                                             'newName',
                                                             'parent'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {'newName': ['const',
                                                                                 '&'],
                                                                     'oldName': ['const',
                                                                                 '&'],
                                                                     'parent': ['const',
                                                                                '*']},
                                                  'types': {'newName': 'MString',
                                                            'oldName': 'MString',
                                                            'parent': 'MString'}}],
                             'rootNamespace': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the name of the root namespace. This name is an absolute namepath (i.e. prefixed by a ":"). An example use of this method would be to set the current namespace to the root namespace, and this could be done as follows:',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The name of the root namespace as an absolute namepath. ',
                                                               'qualifiers': [],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                             'setCurrentNamespace': [{'argInfo': {'name': {'doc': 'the name of the namespace to make current.',
                                                                           'type': 'MString'}},
                                                      'args': [('name',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nSet the specified namespace to be the current namespace. The `name' parameter you specify is relative to whatever namespace is current, but any namespace can be specified by passing an absolute name (e.g. :a:b:c). Note that making a namespace current changes the scene, so any code that calls this method needs to handle undo.",
                                                      'inArgs': ['name'],
                                                      'inverse': ('currentNamespace',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'name': ['const',
                                                                                  '&']},
                                                      'types': {'name': 'MString'}}],
                             'setRelativeNames': [{'argInfo': {'newState': {'doc': "true to turn on relative name lookup, false to turn it off. Maya's default setting is false.",
                                                                            'type': 'bool'}},
                                                   'args': [('newState',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet relative name lookup mode. Note that turning on or off relativeNames mode can change the scene, so any code that calls this method needs to handle undo. See  MNamespace::relativeNames()  for details on relative name lookup.',
                                                   'inArgs': ['newState'],
                                                   'inverse': ('relativeNames',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'newState': []},
                                                   'types': {'newState': 'bool'}}],
                             'stripNamespaceFromName': [{'argInfo': {'fullName': {'doc': 'the full name. ',
                                                                                  'type': 'MString'}},
                                                         'args': [('fullName',
                                                                   'MString',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nStrips the namespace from a full name. For example, given a full name: "a:b:c:d:ball" this method would return: "ball".',
                                                         'inArgs': ['fullName'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Returns the name part of a full name.',
                                                                        'qualifiers': [],
                                                                        'type': 'MString'},
                                                         'returnType': 'MString',
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'fullName': ['const',
                                                                                         '&']},
                                                         'types': {'fullName': 'MString'}}],
                             'validateName': [{'argInfo': {'name': {'doc': 'the specified name ',
                                                                    'type': 'MString'}},
                                               'args': [('name',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\r\nConvert the specified name to a validated name which contains no illegal characters. The leading illegal characters will be removed and other illegal characters will be converted to '_'.",
                                               'inArgs': ['name'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The validated name which contains no illegal characters. ',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': True,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'name': ['const',
                                                                           '&']},
                                               'types': {'name': 'MString'}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'currentNamespace': 'getCurrentNamespace',
                                  'relativeNames': 'getRelativeNames'}},
  'MNodeClass': {'enums': {},
                 'methods': {'addExtensionAttribute': [{'argInfo': {'attr': {'doc': 'The attribute to add',
                                                                             'type': 'MObject'}},
                                                        'args': [('attr',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nAdds an extension attribute to the node class.',
                                                        'inArgs': ['attr'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'attr': ['const',
                                                                                    '&']},
                                                        'types': {'attr': 'MObject'}}],
                             'addToClassification': [{'argInfo': {'str': {'doc': 'The string to add to the classification',
                                                                          'type': 'MString'}},
                                                      'args': [('str',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\nAdds to the node class's classification string.",
                                                      'inArgs': ['str'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'str': ['const',
                                                                                 '&']},
                                                      'types': {'str': 'MString'}}],
                             'attribute': [{'argInfo': {'index': {'doc': 'the index of the attribute ',
                                                                  'type': 'uint'}},
                                            'args': [('index',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFinds the attribute of this node class at the given index. Index order is based on the order in which the attributes were added to the class.',
                                            'inArgs': ['index'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The attribute, or kNullObj if no attribute existed at the given index',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'index': ['unsigned']},
                                            'types': {'index': 'uint'}},
                                           {'argInfo': {'attrName': {'doc': 'name of the attribute to find ',
                                                                     'type': 'MString'}},
                                            'args': [('attrName',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nFinds the attribute of this node class that has the given name.',
                                            'inArgs': ['attrName'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The attribute, or kNullObj if no attribute with the given name could be found',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'attrName': ['const',
                                                                            '&']},
                                            'types': {'attrName': 'MString'}}],
                             'attributeCount': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nGet the number of attributes for the node class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of attributes.',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'classification': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nRetrieves the  classification string  for a node class. This is a string that is used in dependency nodes that are also shaders to provide more detailed  type  information to the rendering system. See the documentation for the MEL commands  getClassification  and  listNodeTypes  for information on the strings that can be provided.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                             'getAttributes': [{'argInfo': {'attr': {'doc': 'The list of attributes',
                                                                     'type': 'MObjectArray'}},
                                                'args': [('attr',
                                                          'MObjectArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nGet the list of attributes for the node class.',
                                                'inArgs': [],
                                                'outArgs': ['attr'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'attr': ['&']},
                                                'types': {'attr': 'MObjectArray'}}],
                             'hasAttribute': [{'argInfo': {'attrName': {'doc': 'Name of attribute to be checked. ',
                                                                        'type': 'MString'}},
                                               'args': [('attrName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns true if the node class already has an attribute with the given name.',
                                               'inArgs': ['attrName'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if the node class has attribute, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'attrName': ['const',
                                                                               '&']},
                                               'types': {'attrName': 'MString'}}],
                             'pluginName': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\nReturns the name of the plug-in this node class was defined in. The name returned is the name of the plug-in on disk, and may contain pathname separators (such as `/') and drive letters (e.g. C:).",
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The name of the plug-in',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                             'removeExtensionAttribute': [{'argInfo': {'attr': {'doc': 'The attribute to remove',
                                                                                'type': 'MObject'}},
                                                           'args': [('attr',
                                                                     'MObject',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nRemoves an extension attribute from the node class.',
                                                           'inArgs': ['attr'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'attr': ['const',
                                                                                       '&']},
                                                           'types': {'attr': 'MObject'}}],
                             'removeExtensionAttributeIfUnset': [{'argInfo': {'attr': {'doc': 'The attribute to remove',
                                                                                       'type': 'MObject'}},
                                                                  'args': [('attr',
                                                                            'MObject',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nRemoves an extension attribute from the given dependency node type but only if there are no nodes in the graph with non-default values for this attribute.',
                                                                  'inArgs': ['attr'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'attr': ['const',
                                                                                              '&']},
                                                                  'types': {'attr': 'MObject'}}],
                             'removeFromClassification': [{'argInfo': {'str': {'doc': 'The string to remove from the classification',
                                                                               'type': 'MString'}},
                                                           'args': [('str',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': "\nRemoves an element from the node class's classification string.",
                                                           'inArgs': ['str'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'str': ['const',
                                                                                      '&']},
                                                           'types': {'str': 'MString'}}],
                             'typeId': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the type id of this node class. The type is is the 4 byte code that is used in the binary file format to identify the type of this node.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'MTypeId'},
                                         'returnType': 'MTypeId',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'typeName': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the type name of this node class. The string returned is the name of the node type as it is used in the ascii file format.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                 'pymelEnums': {}},
  'MNodeMessage': {'enums': {'AttributeMessage': {'valueDocs': {'attributeAdded': 'an attribute has been added to this node',
                                                                'attributeArrayAdded': 'an array attribute has been added to this node',
                                                                'attributeArrayRemoved': 'an array attribute has been removed from this node',
                                                                'attributeEval': 'an attribute of this node has been evaluated',
                                                                'attributeKeyable': 'an attribute of this node has been marked keyable',
                                                                'attributeLocked': 'an attribute of this node has been locked',
                                                                'attributeRemoved': 'an attribute has been removed from this node',
                                                                'attributeRenamed': 'an attribute of this node has had an alias added, removed, or renamed',
                                                                'attributeSet': 'an attribute value of this node has been set',
                                                                'attributeUnkeyable': 'an attribute of this node has been marked unkeyable',
                                                                'attributeUnlocked': 'an attribute of this node has been unlocked',
                                                                'connectionBroken': 'a connection has been broken for an attribute of this node',
                                                                'connectionMade': 'a connection has been made to an attribute of this node',
                                                                'incomingDirection': 'the connection was coming into the node',
                                                                'kAttributeAdded': 'an attribute has been added to this node',
                                                                'kAttributeArrayAdded': 'an array attribute has been added to this node',
                                                                'kAttributeArrayRemoved': 'an array attribute has been removed from this node',
                                                                'kAttributeEval': 'an attribute of this node has been evaluated',
                                                                'kAttributeKeyable': 'an attribute of this node has been marked keyable',
                                                                'kAttributeLocked': 'an attribute of this node has been locked',
                                                                'kAttributeRemoved': 'an attribute has been removed from this node',
                                                                'kAttributeRenamed': 'an attribute of this node has had an alias added, removed, or renamed',
                                                                'kAttributeSet': 'an attribute value of this node has been set',
                                                                'kAttributeUnkeyable': 'an attribute of this node has been marked unkeyable',
                                                                'kAttributeUnlocked': 'an attribute of this node has been unlocked',
                                                                'kConnectionBroken': 'a connection has been broken for an attribute of this node',
                                                                'kConnectionMade': 'a connection has been made to an attribute of this node',
                                                                'kIncomingDirection': 'the connection was coming into the node',
                                                                'kLast': 'last value of the enum',
                                                                'kOtherPlugSet': 'the otherPlug data has been set',
                                                                'last': 'last value of the enum',
                                                                'otherPlugSet': 'the otherPlug data has been set'},
                                                  'values': "Enum('AttributeMessage', {'kConnectionMade': 1, 'kConnectionBroken': 2, 'kAttributeEval': 4, 'kAttributeSet': 8, 'kAttributeLocked': 16, 'kAttributeUnlocked': 32, 'kAttributeAdded': 64, 'kAttributeRemoved': 128, 'kAttributeRenamed': 256, 'kAttributeKeyable': 512, 'kAttributeUnkeyable': 1024, 'kIncomingDirection': 2048, 'kAttributeArrayAdded': 4096, 'kAttributeArrayRemoved': 8192, 'kOtherPlugSet': 16384, 'kLast': 32768})"},
                             'KeyableChangeMsg': {'valueDocs': {'kKeyChangeInvalid': '',
                                                                'kKeyChangeLast': '',
                                                                'kMakeKeyable': '',
                                                                'kMakeUnkeyable': '',
                                                                'keyChangeInvalid': '',
                                                                'keyChangeLast': '',
                                                                'makeKeyable': '',
                                                                'makeUnkeyable': ''},
                                                  'values': "Enum('KeyableChangeMsg', {'kKeyChangeInvalid': 0, 'kMakeKeyable': 1, 'kMakeUnkeyable': 2, 'kKeyChangeLast': 3})"}},
                   'methods': {'addAttributeAddedOrRemovedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                                  'type': 'void'},
                                                                                   'func': {'doc': "the callback function, which takes the following parameters:  msg the kind of attribute change triggering the callback  plug the node's plug where the connection changed  clientData User defined data passed to the callback function   ",
                                                                                            'type': ('MNodeMessage',
                                                                                                     'MAttrPlugFunction')},
                                                                                   'node': {'doc': 'the node to register the callback for ',
                                                                                            'type': 'MObject'}},
                                                                       'args': [('node',
                                                                                 'MObject',
                                                                                 'in'),
                                                                                ('func',
                                                                                 ('MNodeMessage',
                                                                                  'MAttrPlugFunction'),
                                                                                 'in'),
                                                                                ('clientData',
                                                                                 'void',
                                                                                 'in')],
                                                                       'defaults': {'clientData': None},
                                                                       'deprecated': False,
                                                                       'doc': '\r\nRegisters callbacks for attribute add/removed messages. This is a more specific version of addAttributeChanged as only attribute added and attribute removed messages will trigger the callback.',
                                                                       'inArgs': ['node',
                                                                                  'func',
                                                                                  'clientData'],
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                      'qualifiers': [],
                                                                                      'type': 'MCallbackId'},
                                                                       'returnType': 'MCallbackId',
                                                                       'static': True,
                                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                          'clientData': ['*'],
                                                                                          'func': [],
                                                                                          'node': ['&']},
                                                                       'types': {'clientData': 'void',
                                                                                 'func': ('MNodeMessage',
                                                                                          'MAttrPlugFunction'),
                                                                                 'node': 'MObject'}}],
                               'addAttributeChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                           'type': 'void'},
                                                                            'func': {'doc': "the callback function, which takes the following parameters:  msg the kind of attribute change triggering the callback  plug the node's plug where the connection changed  otherPlug the plug opposite the node's plug where the connection changed  clientData User defined data passed to the callback function   ",
                                                                                     'type': ('MNodeMessage',
                                                                                              'MAttr2PlugFunction')},
                                                                            'node': {'doc': 'the node to register the callback for. If this is a NULL MObject then the callback applies to all nodes. ',
                                                                                     'type': 'MObject'}},
                                                                'args': [('node',
                                                                          'MObject',
                                                                          'in'),
                                                                         ('func',
                                                                          ('MNodeMessage',
                                                                           'MAttr2PlugFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': '\r\nThis method registers a callback for attribute changed messages. See the AttributeChanged enum for a list of all possible messages that will trigger the callback.',
                                                                'inArgs': ['node',
                                                                           'func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'func': [],
                                                                                   'node': ['&']},
                                                                'types': {'clientData': 'void',
                                                                          'func': ('MNodeMessage',
                                                                                   'MAttr2PlugFunction'),
                                                                          'node': 'MObject'}}],
                               'addKeyableChangeOverride': [{'argInfo': {'clientData': {'doc': 'User defined data passed back to the user. ',
                                                                                        'type': 'void'},
                                                                         'func': {'doc': 'the callback function, which takes the following parameters:  plug - The plug that triggered the callback.  clientData - User defined data passed to the callback function.  eventType - Description of the event.  decision - Return true to accept the keyable state change or false to reject it.   ',
                                                                                  'type': ('MNodeMessage',
                                                                                           'MKeyableFunction')},
                                                                         'plug': {'doc': 'The plug to which to attach the callback. ',
                                                                                  'type': 'MPlug'}},
                                                             'args': [('plug',
                                                                       'MPlug',
                                                                       'in'),
                                                                      ('func',
                                                                       ('MNodeMessage',
                                                                        'MKeyableFunction'),
                                                                       'in'),
                                                                      ('clientData',
                                                                       'void',
                                                                       'in')],
                                                             'defaults': {'clientData': None},
                                                             'deprecated': False,
                                                             'doc': '\r\nAttribute keyable state change override. \r\n',
                                                             'inArgs': ['plug',
                                                                        'func',
                                                                        'clientData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'clientData': ['*'],
                                                                                'func': [],
                                                                                'plug': ['&']},
                                                             'types': {'clientData': 'void',
                                                                       'func': ('MNodeMessage',
                                                                                'MKeyableFunction'),
                                                                       'plug': 'MPlug'}}],
                               'addNameChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                      'type': 'void'},
                                                                       'func': {'doc': 'the callback function, which takes the following parameters:  node the node  prevName the previous name of the node  clientData User defined data passed to the callback function   ',
                                                                                'type': ('MMessage',
                                                                                         'MNodeStringFunction')},
                                                                       'node': {'doc': 'the node. If this is a NULL MObject then the callback applies to all node name changes. ',
                                                                                'type': 'MObject'}},
                                                           'args': [('node',
                                                                     'MObject',
                                                                     'in'),
                                                                    ('func',
                                                                     ('MMessage',
                                                                      'MNodeStringFunction'),
                                                                     'in'),
                                                                    ('clientData',
                                                                     'void',
                                                                     'in')],
                                                           'defaults': {'clientData': None},
                                                           'deprecated': False,
                                                           'doc': '\r\nRegisters a callback for name changed messages.',
                                                           'inArgs': ['node',
                                                                      'func',
                                                                      'clientData'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                          'qualifiers': [],
                                                                          'type': 'MCallbackId'},
                                                           'returnType': 'MCallbackId',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'clientData': ['*'],
                                                                              'func': [],
                                                                              'node': ['&']},
                                                           'types': {'clientData': 'void',
                                                                     'func': ('MMessage',
                                                                              'MNodeStringFunction'),
                                                                     'node': 'MObject'}}],
                               'addNodeAboutToDeleteCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                            'type': 'void'},
                                                                             'func': {'doc': 'the callback function, which takes the following parameters:  node the node that will be deleted  modifier DG modifier used to delete the node  clientData User defined data passed to the callback function   ',
                                                                                      'type': ('MMessage',
                                                                                               'MNodeModifierFunction')},
                                                                             'node': {'doc': 'the node to register the callback for ',
                                                                                      'type': 'MObject'}},
                                                                 'args': [('node',
                                                                           'MObject',
                                                                           'in'),
                                                                          ('func',
                                                                           ('MMessage',
                                                                            'MNodeModifierFunction'),
                                                                           'in'),
                                                                          ('clientData',
                                                                           'void',
                                                                           'in')],
                                                                 'defaults': {'clientData': None},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nRegisters a callback which will get called when a node is about to be deleted.',
                                                                 'inArgs': ['node',
                                                                            'func',
                                                                            'clientData'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                'qualifiers': [],
                                                                                'type': 'MCallbackId'},
                                                                 'returnType': 'MCallbackId',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'clientData': ['*'],
                                                                                    'func': [],
                                                                                    'node': ['&']},
                                                                 'types': {'clientData': 'void',
                                                                           'func': ('MMessage',
                                                                                    'MNodeModifierFunction'),
                                                                           'node': 'MObject'}}],
                               'addNodeDestroyedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                        'type': 'void'},
                                                                         'func': {'doc': 'the callback function, which takes the following parameters:  clientData User defined data passed to the callback function   ',
                                                                                  'type': ('MMessage',
                                                                                           'MBasicFunction')},
                                                                         'node': {'doc': 'the node to register the callback for ',
                                                                                  'type': 'MObject'}},
                                                             'args': [('node',
                                                                       'MObject',
                                                                       'in'),
                                                                      ('func',
                                                                       ('MMessage',
                                                                        'MBasicFunction'),
                                                                       'in'),
                                                                      ('clientData',
                                                                       'void',
                                                                       'in')],
                                                             'defaults': {'clientData': None},
                                                             'deprecated': False,
                                                             'doc': '\r\nNodeDestroyed callback. \r\n',
                                                             'inArgs': ['node',
                                                                        'func',
                                                                        'clientData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'clientData': ['*'],
                                                                                'func': [],
                                                                                'node': ['&']},
                                                             'types': {'clientData': 'void',
                                                                       'func': ('MMessage',
                                                                                'MBasicFunction'),
                                                                       'node': 'MObject'}}],
                               'addNodeDirtyCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                    'type': 'void'},
                                                                     'func': {'doc': 'the callback function, which takes the following parameters:  node The node that has become dirty  clientData User defined data passed to the callback function   ',
                                                                              'type': ('MMessage',
                                                                                       'MNodeFunction')},
                                                                     'node': {'doc': 'the node to register the callback for ',
                                                                              'type': 'MObject'}},
                                                         'args': [('node',
                                                                   'MObject',
                                                                   'in'),
                                                                  ('func',
                                                                   ('MMessage',
                                                                    'MNodeFunction'),
                                                                   'in'),
                                                                  ('clientData',
                                                                   'void',
                                                                   'in')],
                                                         'defaults': {'clientData': None},
                                                         'deprecated': False,
                                                         'doc': '\r\nRegisters a callback for node dirty messages.',
                                                         'inArgs': ['node',
                                                                    'func',
                                                                    'clientData'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                        'qualifiers': [],
                                                                        'type': 'MCallbackId'},
                                                         'returnType': 'MCallbackId',
                                                         'static': True,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'clientData': ['*'],
                                                                            'func': [],
                                                                            'node': ['&']},
                                                         'types': {'clientData': 'void',
                                                                   'func': ('MMessage',
                                                                            'MNodeFunction'),
                                                                   'node': 'MObject'}}],
                               'addNodeDirtyPlugCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                        'type': 'void'},
                                                                         'func': {'doc': 'the callback function, which takes the following parameters:  node The node that has become dirty  plug The plug on the node that has become dirty  clientData User defined data passed to the callback function   ',
                                                                                  'type': ('MMessage',
                                                                                           'MNodePlugFunction')},
                                                                         'node': {'doc': 'the node to register the callback for ',
                                                                                  'type': 'MObject'}},
                                                             'args': [('node',
                                                                       'MObject',
                                                                       'in'),
                                                                      ('func',
                                                                       ('MMessage',
                                                                        'MNodePlugFunction'),
                                                                       'in'),
                                                                      ('clientData',
                                                                       'void',
                                                                       'in')],
                                                             'defaults': {'clientData': None},
                                                             'deprecated': False,
                                                             'doc': '\r\nRegisters a callback for node dirty messages. This callback provides the plug on the node that was dirtied. Only provides dirty information on input plugs.',
                                                             'inArgs': ['node',
                                                                        'func',
                                                                        'clientData'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'clientData': ['*'],
                                                                                'func': [],
                                                                                'node': ['&']},
                                                             'types': {'clientData': 'void',
                                                                       'func': ('MMessage',
                                                                                'MNodePlugFunction'),
                                                                       'node': 'MObject'}}],
                               'addNodePreRemovalCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                         'type': 'void'},
                                                                          'func': {'doc': 'the callback function, which takes the following parameters:  node the node that is being deleted  clientData User defined data passed to the callback function   ',
                                                                                   'type': ('MMessage',
                                                                                            'MNodeFunction')},
                                                                          'node': {'doc': 'the node to register the callback for ',
                                                                                   'type': 'MObject'}},
                                                              'args': [('node',
                                                                        'MObject',
                                                                        'in'),
                                                                       ('func',
                                                                        ('MMessage',
                                                                         'MNodeFunction'),
                                                                        'in'),
                                                                       ('clientData',
                                                                        'void',
                                                                        'in')],
                                                              'defaults': {'clientData': None},
                                                              'deprecated': False,
                                                              'doc': '\r\nRegisters a callback which will get called before a node is deleted. This callback is called before connections on the node are removed. Unlike the aboutToDelete callback, this callback will be invoked whenever the node is deleted, even during a redo.',
                                                              'inArgs': ['node',
                                                                         'func',
                                                                         'clientData'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                             'qualifiers': [],
                                                                             'type': 'MCallbackId'},
                                                              'returnType': 'MCallbackId',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'clientData': ['*'],
                                                                                 'func': [],
                                                                                 'node': ['&']},
                                                              'types': {'clientData': 'void',
                                                                        'func': ('MMessage',
                                                                                 'MNodeFunction'),
                                                                        'node': 'MObject'}}],
                               'addUuidChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                      'type': 'void'},
                                                                       'func': {'doc': 'the callback function, which takes the following parameters:  node the node  prevUuid the previous UUID of the node  clientData User defined data passed to the callback function   ',
                                                                                'type': ('MMessage',
                                                                                         'MNodeUuidFunction')},
                                                                       'node': {'doc': 'the node. If this is a NULL MObject then the callback applies to all node UUID changes. ',
                                                                                'type': 'MObject'}},
                                                           'args': [('node',
                                                                     'MObject',
                                                                     'in'),
                                                                    ('func',
                                                                     ('MMessage',
                                                                      'MNodeUuidFunction'),
                                                                     'in'),
                                                                    ('clientData',
                                                                     'void',
                                                                     'in')],
                                                           'defaults': {'clientData': None},
                                                           'deprecated': False,
                                                           'doc': '\r\nRegisters a callback for UUID changed messages.',
                                                           'inArgs': ['node',
                                                                      'func',
                                                                      'clientData'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                          'qualifiers': [],
                                                                          'type': 'MCallbackId'},
                                                           'returnType': 'MCallbackId',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'clientData': ['*'],
                                                                              'func': [],
                                                                              'node': ['&']},
                                                           'types': {'clientData': 'void',
                                                                     'func': ('MMessage',
                                                                              'MNodeUuidFunction'),
                                                                     'node': 'MObject'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                   'pymelEnums': {'AttributeMessage': "Enum('AttributeMessage', [('connectionMade', 1), ('kConnectionMade', 1), ('connectionBroken', 2), ('kConnectionBroken', 2), ('attributeEval', 4), ('kAttributeEval', 4), ('attributeSet', 8), ('kAttributeSet', 8), ('attributeLocked', 16), ('kAttributeLocked', 16), ('attributeUnlocked', 32), ('kAttributeUnlocked', 32), ('attributeAdded', 64), ('kAttributeAdded', 64), ('attributeRemoved', 128), ('kAttributeRemoved', 128), ('attributeRenamed', 256), ('kAttributeRenamed', 256), ('attributeKeyable', 512), ('kAttributeKeyable', 512), ('attributeUnkeyable', 1024), ('kAttributeUnkeyable', 1024), ('incomingDirection', 2048), ('kIncomingDirection', 2048), ('attributeArrayAdded', 4096), ('kAttributeArrayAdded', 4096), ('attributeArrayRemoved', 8192), ('kAttributeArrayRemoved', 8192), ('otherPlugSet', 16384), ('kOtherPlugSet', 16384), ('last', 32768), ('kLast', 32768)], multiKeys=True)",
                                  'KeyableChangeMsg': "Enum('KeyableChangeMsg', [('keyChangeInvalid', 0), ('kKeyChangeInvalid', 0), ('makeKeyable', 1), ('kMakeKeyable', 1), ('makeUnkeyable', 2), ('kMakeUnkeyable', 2), ('keyChangeLast', 3), ('kKeyChangeLast', 3)], multiKeys=True)"}},
  'MNurbsIntersector': {'enums': {},
                        'methods': {'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'create': [{'argInfo': {'matrix': {'doc': 'specify the mapping to apply for transforming points that are specified in the getClosestPoint method into the object space of the NURBS surface.',
                                                                       'type': 'MMatrix'},
                                                            'nurbsObject': {'doc': 'a NURBS surface object . ',
                                                                            'type': 'MObject'}},
                                                'args': [('nurbsObject',
                                                          'MObject',
                                                          'in'),
                                                         ('matrix',
                                                          'MMatrix',
                                                          'in')],
                                                'defaults': {'matrix': 'MMatrix::identity'},
                                                'deprecated': False,
                                                'doc': '\r\nThis method creates the data required by the intersector. It is a heavy operation that should be called only when necessary, such as when the underlying NURBS surface or the matrix changes.',
                                                'inArgs': ['nurbsObject',
                                                           'matrix'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'matrix': ['const',
                                                                              '&'],
                                                                   'nurbsObject': ['&']},
                                                'types': {'matrix': 'MMatrix',
                                                          'nurbsObject': 'MObject'}}],
                                    'getClosestPoint': [{'argInfo': {'maxDistance': {'doc': 'Maximum distance to consider in object space.',
                                                                                     'type': 'double'},
                                                                     'nurbsPoint': {'doc': 'Resulting closest point in object space. ',
                                                                                    'type': 'MPointOnNurbs'},
                                                                     'point': {'doc': "Specifies the location for which to evaluate the closest point on the NURBS surface. `point' is transformed using the matrix parameter passed to the create() method, so for example if your matrix maps world to object space, then `point' should be specified in world space. ",
                                                                               'type': 'MPoint'}},
                                                         'args': [('point',
                                                                   'MPoint',
                                                                   'in'),
                                                                  ('nurbsPoint',
                                                                   'MPointOnNurbs',
                                                                   'out'),
                                                                  ('maxDistance',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {'maxDistance': 'DBL_MAX'},
                                                         'deprecated': False,
                                                         'doc': '\r\nThis method finds the closest point. Information is returned in the nurbsPoint object.',
                                                         'inArgs': ['point',
                                                                    'maxDistance'],
                                                         'outArgs': ['nurbsPoint'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'maxDistance': [],
                                                                            'nurbsPoint': ['&'],
                                                                            'point': ['const',
                                                                                      '&']},
                                                         'types': {'maxDistance': 'double',
                                                                   'nurbsPoint': 'MPointOnNurbs',
                                                                   'point': 'MPoint'}}],
                                    'getIntersect': [{'argInfo': {'alongThisDirection': {'doc': 'Direction of ray to test ',
                                                                                         'type': 'MVector'},
                                                                  'pntOfIntersection': {'doc': 'Storage for closest point of intersection (if any) ',
                                                                                        'type': 'MPoint'},
                                                                  'rayStartingPoint': {'doc': 'Starting location of ray to test ',
                                                                                       'type': 'MPoint'},
                                                                  'tolerance': {'doc': 'The epsilon value in the calculation',
                                                                                'type': 'double'},
                                                                  'u': {'doc': 'U parameter of intersection (if any) ',
                                                                        'type': 'double'},
                                                                  'v': {'doc': 'V parameter of intersection (if any) ',
                                                                        'type': 'double'}},
                                                      'args': [('rayStartingPoint',
                                                                'MPoint',
                                                                'in'),
                                                               ('alongThisDirection',
                                                                'MVector',
                                                                'in'),
                                                               ('u',
                                                                'double',
                                                                'out'),
                                                               ('v',
                                                                'double',
                                                                'out'),
                                                               ('pntOfIntersection',
                                                                'MPoint',
                                                                'out'),
                                                               ('tolerance',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis method finds the first point of intersection of the NURBS surface with a ray (a vector at a point). The point is returned in the pntOfIntersection object, and the U and V parameters of the point are returned in the u and v variables respectively.',
                                                      'inArgs': ['rayStartingPoint',
                                                                 'alongThisDirection',
                                                                 'tolerance'],
                                                      'outArgs': ['u',
                                                                  'v',
                                                                  'pntOfIntersection'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'alongThisDirection': ['const',
                                                                                                '&'],
                                                                         'pntOfIntersection': ['&'],
                                                                         'rayStartingPoint': ['const',
                                                                                              '&'],
                                                                         'tolerance': [],
                                                                         'u': ['&'],
                                                                         'v': ['&']},
                                                      'types': {'alongThisDirection': 'MVector',
                                                                'pntOfIntersection': 'MPoint',
                                                                'rayStartingPoint': 'MPoint',
                                                                'tolerance': 'double',
                                                                'u': 'double',
                                                                'v': 'double'}}],
                                    'getIntersects': [{'argInfo': {'alongThisDirection': {'doc': 'Direction of ray to test ',
                                                                                          'type': 'MVector'},
                                                                   'points': {'doc': 'Storage for points of intersection (if any) ',
                                                                              'type': 'MPointArray'},
                                                                   'rayStartingPoint': {'doc': 'Starting location of ray to test ',
                                                                                        'type': 'MPoint'},
                                                                   'tolerance': {'doc': 'The epsilon value in the calculation',
                                                                                 'type': 'double'},
                                                                   'uArray': {'doc': 'U parameters of intersection (if any) ',
                                                                              'type': 'MDoubleArray'},
                                                                   'vArray': {'doc': 'V parameters of intersection (if any) ',
                                                                              'type': 'MDoubleArray'}},
                                                       'args': [('rayStartingPoint',
                                                                 'MPoint',
                                                                 'in'),
                                                                ('alongThisDirection',
                                                                 'MVector',
                                                                 'in'),
                                                                ('uArray',
                                                                 'MDoubleArray',
                                                                 'in'),
                                                                ('vArray',
                                                                 'MDoubleArray',
                                                                 'in'),
                                                                ('points',
                                                                 'MPointArray',
                                                                 'out'),
                                                                ('tolerance',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method finds all the points of intersection of the NURBS surface with a ray (a vector at a point). The points are returned in the points object, and the U and V parameters of the points are returned in the uArray and vArray objects respectively.',
                                                       'inArgs': ['rayStartingPoint',
                                                                  'alongThisDirection',
                                                                  'uArray',
                                                                  'vArray',
                                                                  'tolerance'],
                                                       'outArgs': ['points'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'alongThisDirection': ['const',
                                                                                                 '&'],
                                                                          'points': ['&'],
                                                                          'rayStartingPoint': ['const',
                                                                                               '&'],
                                                                          'tolerance': [],
                                                                          'uArray': ['&'],
                                                                          'vArray': ['&']},
                                                       'types': {'alongThisDirection': 'MVector',
                                                                 'points': 'MPointArray',
                                                                 'rayStartingPoint': 'MPoint',
                                                                 'tolerance': 'double',
                                                                 'uArray': 'MDoubleArray',
                                                                 'vArray': 'MDoubleArray'}}],
                                    'isCreated': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method returns true if the intersector is created. False is returned otherwise. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                        'pymelEnums': {}},
  'MObject': {'enums': {},
              'methods': {'__eq__': [{'argInfo': {'other': {'doc': '',
                                                            'type': 'MObject'}},
                                      'args': [('other',
                                                'MObject',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe comparison operator. Returns true if both MObjects refer to the same Maya object. \r\n',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MObject'}}],
                          '__ne__': [{'argInfo': {'other': {'doc': '',
                                                            'type': 'MObject'}},
                                      'args': [('other',
                                                'MObject',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe inequality operator. Returns true if the MObjects refer to different Maya objects. \r\n',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MObject'}}],
                          'apiType': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nDetermines the exact type of the Maya internal Object.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': ' Exact type of the Maya internal Object. May be general or specific types of DG Nodes or Attributes.   ',
                                                      'qualifiers': [],
                                                      'type': ('MFn',
                                                               'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                          'apiTypeStr': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nReturns a string that gives the object's type is a readable form. This is useful for debugging when type of an object needs to be printed.",
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' a string containing the type name of the object   ',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'hasFn': [{'argInfo': {'fs': {'doc': 'Function Set type',
                                                        'type': ('MFn',
                                                                 'Type')}},
                                     'args': [('fs',
                                               ('MFn', 'Type'),
                                               'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nDetermines the whether or not the internal Object is compatible with the given Function Type.',
                                     'inArgs': ['fs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': ' true Is compatible  false Is not compatible, or is null (object does not exist).   ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'fs': []},
                                     'types': {'fs': ('MFn', 'Type')}}],
                          'isNull': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nDetermines the whether or not an internal Object exists.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' true Object does not exist  false Object exists   ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}]},
              'pymelEnums': {}},
  'MObjectArray': {'enums': {},
                   'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                   ('setLength', 'length')],
                   'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}},
                                               {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                   'type': 'MObject'}},
                                           'args': [('element',
                                                     'MObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': ['const',
                                                                          '&']},
                                           'types': {'element': 'MObject'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                'type': 'MObjectArray'}},
                                         'args': [('source',
                                                   'MObjectArray',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nCopy the contents of the source array to this array.',
                                         'inArgs': ['source'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'source': ['const',
                                                                       '&']},
                                         'types': {'source': 'MObjectArray'}}],
                               'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                              'type': 'MObject__array'}},
                                        'args': [('array',
                                                  'MObject__array',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                        'inArgs': [],
                                        'outArgs': ['array'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'array': []},
                                        'types': {'array': 'MObject__array'}}],
                               'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                   'type': 'MObject'},
                                                       'index': {'doc': 'the index of the element to set to the the new value',
                                                                 'type': 'uint'}},
                                           'args': [('element',
                                                     'MObject',
                                                     'in'),
                                                    ('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element', 'index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': ['const',
                                                                          '&'],
                                                              'index': ['unsigned']},
                                           'types': {'element': 'MObject',
                                                     'index': 'uint'}}],
                               'length': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the number of elements in the instance.',
                                           'inArgs': [],
                                           'inverse': ('setLength',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of elements in the instance ',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned']},
                                           'types': {'index': 'uint'}}],
                               'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'MObject'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'MObject',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the value of the indicated element to the indicated  MObject  value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': ['const',
                                                                       '&'],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'MObject',
                                                  'index': 'uint'}}],
                               'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                     'type': 'uint'}},
                                              'args': [('length',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                              'inArgs': ['length'],
                                              'inverse': ('length', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'length': ['unsigned']},
                                              'types': {'length': 'uint'}}],
                               'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                  'type': 'uint'}},
                                                     'args': [('newIncrement',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                     'inArgs': ['newIncrement'],
                                                     'inverse': ('sizeIncrement',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'newIncrement': ['unsigned']},
                                                     'types': {'newIncrement': 'uint'}}],
                               'sizeIncrement': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                  'inArgs': [],
                                                  'inverse': ('setSizeIncrement',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'length': 'getLength',
                                    'sizeIncrement': 'getSizeIncrement'}},
  'MObjectHandle': {'enums': {},
                    'methods': {'__eq__': [{'argInfo': {'obj': {'doc': 'MObject to test.',
                                                                'type': 'MObject'}},
                                            'args': [('obj',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if the  MObjectHandle  is a handle for the given  MObject .',
                                            'inArgs': ['obj'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true if the MObject is handled by the MObjectHandle, false otherwise. ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'obj': ['const',
                                                                       '&']},
                                            'types': {'obj': 'MObject'}},
                                           {'argInfo': {'handle': {'doc': 'MObjectHandle to test.',
                                                                   'type': 'MObjectHandle'}},
                                            'args': [('handle',
                                                      'MObjectHandle',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if the  MObjectHandle  handles the same  MObject  as this  MObjectHandle .',
                                            'inArgs': ['handle'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true if the MObjectHandles are the same, false otherwise. ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'handle': ['const',
                                                                          '&']},
                                            'types': {'handle': 'MObjectHandle'}}],
                                '__ne__': [{'argInfo': {'obj': {'doc': 'MObject to test.',
                                                                'type': 'MObject'}},
                                            'args': [('obj',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if the  MObjectHandle  is not a handle for the given  MObject .',
                                            'inArgs': ['obj'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true if the MObject is not handled by the MObjectHandle, false otherwise. ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'obj': ['const',
                                                                       '&']},
                                            'types': {'obj': 'MObject'}},
                                           {'argInfo': {'handle': {'doc': 'MObjectHandle to test.',
                                                                   'type': 'MObjectHandle'}},
                                            'args': [('handle',
                                                      'MObjectHandle',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if the  MObjectHandle  does not handle the same  MObject  as this  MObjectHandle .',
                                            'inArgs': ['handle'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'true MObjectHandles are not the same, false otherwise. ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'handle': ['const',
                                                                          '&']},
                                            'types': {'handle': 'MObjectHandle'}}],
                                'hashCode': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns a hash code for the internal Maya object referenced by the  MObject  within this  MObjectHandle . If the  MObject  is null or no longer alive then 0 will be returned, otherwise the hash code is guaranteed to be non-zero.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                'isAlive': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "\r\nReturns the live state of the associated  MObject . An object can still be 'alive' but not 'valid' (eg. a deleted object that resides in the undo queue).",
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                'isValid': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the validity of the associated  MObject .',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                'object': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the  MObject  associated with this handle. The returned  MObject  will be  MObject::kNullObj  if the object is invalid.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                'objectHashCode': [{'argInfo': {'obj': {'doc': 'MObject whose hash code is requested.',
                                                                        'type': 'MObject'}},
                                                    'args': [('obj',
                                                              'MObject',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturns a hash code for the provided  MObject . The user is responsible for the validity of the provided  MObject  when using this method.',
                                                    'inArgs': ['obj'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The hash code. ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': True,
                                                    'typeQualifiers': {'obj': ['const',
                                                                               '&']},
                                                    'types': {'obj': 'MObject'}}],
                                'objectRef': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the  MObject  associated with this handle. This provides read-only access to the  MObject  that  MObjectHandle  holds onto. This method will always return the object that belongs to  MObjectHandle  regardless of its validity. API users should use caution when using  MObject  data when it is not valid, and should never use the data when  MObjectHandle  indicates that the  MObject  is NOT alive.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['&'],
                                                              'type': 'MObject'},
                                               'returnType': 'MObject',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                    'pymelEnums': {}},
  'MObjectListFilter': {'enums': {'MFilterType': {'valueDocs': {'exclusionList': 'Exclude only items on the list.',
                                                                'inclusionList': 'Include only items on the list.',
                                                                'kExclusionList': 'Exclude only items on the list.',
                                                                'kInclusionList': 'Include only items on the list.',
                                                                'kNumberOfFilterTypes': 'Not to be used. This is the number of filter types.',
                                                                'numberOfFilterTypes': 'Not to be used. This is the number of filter types.'},
                                                  'values': "Enum('MFilterType', {'kInclusionList': 0, 'kExclusionList': 1, 'kNumberOfFilterTypes': 2})"},
                                  'MSceneUpdateType': {'valueDocs': {'addRemoveObjects': 'List update is dependent on addition or removal of dag objects from the scene.',
                                                                     'kAddRemoveObjects': 'List update is dependent on addition or removal of dag objects from the scene.',
                                                                     'kNone': 'List update is not dependent on scene changes.',
                                                                     'none': 'List update is not dependent on scene changes.'},
                                                       'values': "Enum('MSceneUpdateType', {'kNone': 0, 'kAddRemoveObjects': 1})"}},
                        'invertibles': [('setFilterType', 'filterType')],
                        'methods': {'UIname': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nQuery the UI name',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['&'],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'dependentOnSceneUpdates': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nReturn whether the update of the filter list is dependent on scene updates.',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': ('MObjectListFilter',
                                                                                         'MSceneUpdateType')},
                                                                 'returnType': ('MObjectListFilter',
                                                                                'MSceneUpdateType'),
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                    'deregisterFilter': [{'argInfo': {'filter': {'doc': 'Filter to deregister',
                                                                                 'type': 'MObjectListFilter'}},
                                                          'args': [('filter',
                                                                    'MObjectListFilter',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nDeregister the object filter from the list of available filters.',
                                                          'inArgs': ['filter'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': True,
                                                          'typeQualifiers': {'filter': ['const',
                                                                                        '&']},
                                                          'types': {'filter': 'MObjectListFilter'}}],
                                    'filterType': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nQuery the filter type',
                                                    'inArgs': [],
                                                    'inverse': ('setFilterType',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': ('MObjectListFilter',
                                                                            'MFilterType')},
                                                    'returnType': ('MObjectListFilter',
                                                                   'MFilterType'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'getList': [{'argInfo': {'list': {'doc': 'Object filter list (MSelectionList)',
                                                                      'type': 'MSelectionList'}},
                                                 'args': [('list',
                                                           'MSelectionList',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nThis method will return the selection list to use for filtering scene rendering. Currently filtering at the component level is not supported. Any components specified for selection items in the list will be ignored.',
                                                 'inArgs': [],
                                                 'outArgs': ['list'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'list': ['&']},
                                                 'types': {'list': 'MSelectionList'}}],
                                    'name': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nQuery the name identifier.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['&'],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'registerFilter': [{'argInfo': {'filter': {'doc': 'Filter to register',
                                                                               'type': 'MObjectListFilter'}},
                                                        'args': [('filter',
                                                                  'MObjectListFilter',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRegister the object filter as one of an available set of filters.',
                                                        'inArgs': ['filter'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'filter': ['const',
                                                                                      '&']},
                                                        'types': {'filter': 'MObjectListFilter'}}],
                                    'requireListUpdate': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nThis method is called by Maya to determine whether the contents of the object list for the filter has changed since the last requireLastUpdate() call was made. If the list has changed then  getList()  will be called to query for the contents of the filter.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                    'setFilterType': [{'argInfo': {'filterType': {'doc': 'Filter type defined by MObjectListFilter::MFilterType. ',
                                                                                  'type': ('MObjectListFilter',
                                                                                           'MFilterType')}},
                                                       'args': [('filterType',
                                                                 ('MObjectListFilter',
                                                                  'MFilterType'),
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSet the filter type.',
                                                       'inArgs': ['filterType'],
                                                       'inverse': ('filterType',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'filterType': []},
                                                       'types': {'filterType': ('MObjectListFilter',
                                                                                'MFilterType')}}],
                                    'setUIName': [{'argInfo': {'name': {'doc': 'UI name ',
                                                                        'type': 'MString'}},
                                                   'args': [('name',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSet the UI name',
                                                   'inArgs': ['name'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'name': ['const',
                                                                               '&']},
                                                   'types': {'name': 'MString'}}]},
                        'pymelEnums': {'MFilterType': "Enum('MFilterType', [('inclusionList', 0), ('kInclusionList', 0), ('exclusionList', 1), ('kExclusionList', 1), ('numberOfFilterTypes', 2), ('kNumberOfFilterTypes', 2)], multiKeys=True)",
                                       'MSceneUpdateType': "Enum('MSceneUpdateType', [('none', 0), ('kNone', 0), ('addRemoveObjects', 1), ('kAddRemoveObjects', 1)], multiKeys=True)"},
                        'pymelMethods': {'filterType': 'getFilterType'}},
  'MObjectSetMessage': {'enums': {},
                        'methods': {'addSetMembersModifiedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                                  'type': 'void'},
                                                                                   'func': {'doc': 'the callback function',
                                                                                            'type': ('MMessage',
                                                                                                     'MNodeFunction')},
                                                                                   'node': {'doc': 'the set to register the callback for ',
                                                                                            'type': 'MObject'}},
                                                                       'args': [('node',
                                                                                 'MObject',
                                                                                 'in'),
                                                                                ('func',
                                                                                 ('MMessage',
                                                                                  'MNodeFunction'),
                                                                                 'in'),
                                                                                ('clientData',
                                                                                 'void',
                                                                                 'in')],
                                                                       'defaults': {'clientData': None},
                                                                       'deprecated': False,
                                                                       'doc': '\nRegisters callbacks for set modified messages.',
                                                                       'inArgs': ['node',
                                                                                  'func',
                                                                                  'clientData'],
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                      'qualifiers': [],
                                                                                      'type': 'MCallbackId'},
                                                                       'returnType': 'MCallbackId',
                                                                       'static': True,
                                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                          'clientData': ['*'],
                                                                                          'func': [],
                                                                                          'node': ['&']},
                                                                       'types': {'clientData': 'void',
                                                                                 'func': ('MMessage',
                                                                                          'MNodeFunction'),
                                                                                 'node': 'MObject'}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                        'pymelEnums': {}},
  'MPaintMessage': {'enums': {},
                    'methods': {'addVertexColorCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                       'type': 'void'},
                                                                        'func': {'doc': 'the callback function  path The DAG path of the object being painted  object The components (e.g. vertices, faces) being painted  plug The plug being painted  colors The colors that were applied to the components  clientData User defined data passed to the callback function   ',
                                                                                 'type': ('MPaintMessage',
                                                                                          'MPathObjectPlugColorsFunction')}},
                                                            'args': [('func',
                                                                      ('MPaintMessage',
                                                                       'MPathObjectPlugColorsFunction'),
                                                                      'in'),
                                                                     ('clientData',
                                                                      'void',
                                                                      'in')],
                                                            'defaults': {'clientData': None},
                                                            'deprecated': False,
                                                            'doc': '\nAdds a new callback on vertex color paint.',
                                                            'inArgs': ['func',
                                                                       'clientData'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                           'qualifiers': [],
                                                                           'type': 'MCallbackId'},
                                                            'returnType': 'MCallbackId',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'clientData': ['*'],
                                                                               'func': []},
                                                            'types': {'clientData': 'void',
                                                                      'func': ('MPaintMessage',
                                                                               'MPathObjectPlugColorsFunction')}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                    'pymelEnums': {}},
  'MParentingEdit': {'enums': {},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'editType': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nVirtual method used to return the edit type of this edit, which is  MEdit::kParentEdit .',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'MEdit::kParentEdit',
                                                              'qualifiers': [],
                                                              'type': ('MEdit',
                                                                       'EditType')},
                                               'returnType': ('MEdit',
                                                              'EditType'),
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'parent': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the parent dag object involved in this edit. The parent can only be returned when the related reference or assembly is loaded. When the reference or assembly is unloaded, only the parent name string may be queried successfully.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The parent dag object involved in this edit',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                 'parentName': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the name of the parent dag object involved in this edit.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The name of the parent dag object involved in this edit',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                                 'parentedObject': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturns the dag object which was parented in this edit. The parented object can only be returned when the related reference or assembly is loaded. When the reference or assembly is unloaded, only the name of the parented object may be queried successfully. queried.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The dag object which was parented in this edit',
                                                                    'qualifiers': [],
                                                                    'type': 'MObject'},
                                                     'returnType': 'MObject',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                 'parentedObjectName': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nReturns the dag object which was parented in this edit. The parented object can only be returned when the related reference or assembly is loaded. When the reference or assembly is unloaded, only the name of the parented object may be queried successfully. queried.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The dag object which was parented in this edit',
                                                                        'qualifiers': [],
                                                                        'type': 'MString'},
                                                         'returnType': 'MString',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                                         'types': {}}]},
                     'pymelEnums': {}},
  'MPlane': {'enums': {},
             'methods': {'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['*'],
                                                       'type': 'char'},
                                        'returnType': 'char',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'directedDistance': [{'argInfo': {'point': {'doc': 'The point from which to calculate the distance',
                                                                     'type': 'MVector'}},
                                               'args': [('point',
                                                         'MVector',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the signed distance from the plane to the specified point.',
                                               'inArgs': ['point'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The distance from the specified point to the plane. ',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'point': ['const',
                                                                            '&']},
                                               'types': {'point': 'MVector'}}],
                         'distance': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns the distance of the plane along the normal.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'double'},
                                       'returnType': 'double',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}},
                                      {'argInfo': {'point': {'doc': 'The point from which to calculate the distance',
                                                             'type': 'MVector'}},
                                       'args': [('point',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns the unsigned distance from the plane to the specified point.',
                                       'inArgs': ['point'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The distance from the specified point to the plane. ',
                                                      'qualifiers': [],
                                                      'type': 'double'},
                                       'returnType': 'double',
                                       'static': False,
                                       'typeQualifiers': {'point': ['const',
                                                                    '&']},
                                       'types': {'point': 'MVector'}}],
                         'normal': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nReturns the normal of the plane.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': "The plane's normal ",
                                                    'qualifiers': [],
                                                    'type': 'MVector'},
                                     'returnType': 'MVector',
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                         'setPlane': [{'argInfo': {'a': {'doc': "The plane equation's x coefficent ",
                                                         'type': 'double'},
                                                   'b': {'doc': "The plane equation's y coefficent ",
                                                         'type': 'double'},
                                                   'c': {'doc': "The plane equation's z coefficent ",
                                                         'type': 'double'},
                                                   'd': {'doc': "The plane equation's constant distance term ",
                                                         'type': 'double'}},
                                       'args': [('a', 'double', 'in'),
                                                ('b', 'double', 'in'),
                                                ('c', 'double', 'in'),
                                                ('d', 'double', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nDirectly set the equation of the plane in the form: ax + by +cz + d = 0.',
                                       'inArgs': ['a', 'b', 'c', 'd'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'a': [],
                                                          'b': [],
                                                          'c': [],
                                                          'd': []},
                                       'types': {'a': 'double',
                                                 'b': 'double',
                                                 'c': 'double',
                                                 'd': 'double'}},
                                      {'argInfo': {'d': {'doc': 'The offset of the plane along the normal ',
                                                         'type': 'double'},
                                                   'n': {'doc': "The plane's normal ",
                                                         'type': 'MVector'}},
                                       'args': [('n', 'MVector', 'in'),
                                                ('d', 'double', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSet the equation of the plane from a normal and offset.',
                                       'inArgs': ['n', 'd'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'d': [],
                                                          'n': ['const',
                                                                '&']},
                                       'types': {'d': 'double',
                                                 'n': 'MVector'}}]},
             'pymelEnums': {}},
  'MPlug': {'enums': {'FreeToChangeState': {'valueDocs': {'childrenNotFreeToChange': 'Some of the children are not free to change.',
                                                          'freeToChange': 'All tested plugs are free to change.',
                                                          'kChildrenNotFreeToChange': 'Some of the children are not free to change.',
                                                          'kFreeToChange': 'All tested plugs are free to change.',
                                                          'kNotFreeToChange': 'Some of the tested plugs are not free to change.',
                                                          'notFreeToChange': 'Some of the tested plugs are not free to change.'},
                                            'values': "Enum('FreeToChangeState', {'kFreeToChange': 0, 'kNotFreeToChange': 1, 'kChildrenNotFreeToChange': 2})"},
                      'MValueSelector': {'valueDocs': {'all': 'All values.',
                                                       'changed': 'Changed values.',
                                                       'kAll': 'All values.',
                                                       'kChanged': 'Changed values.',
                                                       'kLastAttrSelector': 'Last value, for counting.',
                                                       'kNonDefault': 'Non default values.',
                                                       'lastAttrSelector': 'Last value, for counting.',
                                                       'nonDefault': 'Non default values.'},
                                         'values': "Enum('MValueSelector', {'kAll': 0, 'kNonDefault': 1, 'kChanged': 2, 'kLastAttrSelector': 3})"}},
            'invertibles': [('setValue', 'getValue'),
                            ('setKeyable', 'isKeyable'),
                            ('setLocked', 'isLocked'),
                            ('setAttribute', 'attribute'),
                            ('setNumElements', 'numElements'),
                            ('setCaching', 'isCachingFlagSet'),
                            ('setChannelBox', 'isChannelBoxFlagSet')],
            'methods': {'MObject': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': ('MPlug',
                                                             'operator')},
                                     'returnType': ('MPlug', 'operator'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                        '__eq__': [{'argInfo': {'other': {'doc': 'Other plug to compare against',
                                                          'type': 'MPlug'}},
                                    'args': [('other', 'MPlug', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nComparison operator for MPlugs.',
                                    'inArgs': ['other'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': ' true If the plugs are equal  false If the plugs are not equal   ',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'other': ['const',
                                                                 '&']},
                                    'types': {'other': 'MPlug'}},
                                   {'argInfo': {'attr': {'doc': 'Attribute to compare against',
                                                         'type': 'MObject'}},
                                    'args': [('attr', 'MObject', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': "\r\nComparison operator for a plug and an attribute. This actually compares the plug's attribute against the other attribute.",
                                    'inArgs': ['attr'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': " true If the plug's attribute is equal  false If the plug's attribute is not equal   ",
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'attr': ['const',
                                                                '&']},
                                    'types': {'attr': 'MObject'}}],
                        '__getitem__': [{'argInfo': {'physicalIndex': {'doc': 'Array index of child plug',
                                                                       'type': 'uint'}},
                                         'args': [('physicalIndex',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method will find and return a plug with the given physical index. This is the same as the  elementByPhysicalIndex  method.',
                                         'inArgs': ['physicalIndex'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'A plug with the given index ',
                                                        'qualifiers': [],
                                                        'type': 'MPlug'},
                                         'returnType': 'MPlug',
                                         'static': False,
                                         'typeQualifiers': {'physicalIndex': ['unsigned']},
                                         'types': {'physicalIndex': 'uint'}},
                                        {'argInfo': {'attr': {'doc': 'The attribute of the plug',
                                                              'type': 'MObject'}},
                                         'args': [('attr',
                                                   'MObject',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                         'inArgs': ['attr'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'A plug referring to the given attribute, or a nullptr plug if the operation fails. ',
                                                        'qualifiers': [],
                                                        'type': 'MPlug'},
                                         'returnType': 'MPlug',
                                         'static': False,
                                         'typeQualifiers': {'attr': ['&']},
                                         'types': {'attr': 'MObject'}}],
                        '__ne__': [{'argInfo': {'other': {'doc': 'Other plug to compare against',
                                                          'type': 'MPlug'}},
                                    'args': [('other', 'MPlug', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nThe inequality operator for MPlugs.',
                                    'inArgs': ['other'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': ' true If the plugs are not equal  false If the plugs are equal   ',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'other': ['const',
                                                                 '&']},
                                    'types': {'other': 'MPlug'}},
                                   {'argInfo': {'attr': {'doc': 'Attribute to compare against',
                                                         'type': 'MObject'}},
                                    'args': [('attr', 'MObject', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': "\r\nThe inequality operator for a plug and an attribute. This actually compares the plug's attribute against the other attribute.",
                                    'inArgs': ['attr'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': " true If the plug's attribute is not equal  false If the plug's attribute is equal   ",
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'attr': ['const',
                                                                '&']},
                                    'types': {'attr': 'MObject'}}],
                        'array': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nReturns the array to which this element plug belongs. This method is only valid for networked element plugs.',
                                   'inArgs': [],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'The array of this plug.',
                                                  'qualifiers': [],
                                                  'type': 'MPlug'},
                                   'returnType': 'MPlug',
                                   'static': False,
                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                   'types': {}}],
                        'asBool': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Value of plug as a bool',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                    'types': {}},
                                   {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                        'type': 'MDGContext'}},
                                    'args': [('ctx', 'MDGContext', 'in')],
                                    'defaults': {},
                                    'deprecated': True,
                                    'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                    'inArgs': ['ctx'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Value of plug as a bool',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                       'ctx': ['const',
                                                               '&']},
                                    'types': {'ctx': 'MDGContext'}}],
                        'asChar': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Value of plug as a char',
                                                   'qualifiers': [],
                                                   'type': 'char'},
                                    'returnType': 'char',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                    'types': {}},
                                   {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                        'type': 'MDGContext'}},
                                    'args': [('ctx', 'MDGContext', 'in')],
                                    'defaults': {},
                                    'deprecated': True,
                                    'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                    'inArgs': ['ctx'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Value of plug as a char',
                                                   'qualifiers': [],
                                                   'type': 'char'},
                                    'returnType': 'char',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                       'ctx': ['const',
                                                               '&']},
                                    'types': {'ctx': 'MDGContext'}}],
                        'asDouble': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as a double',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}},
                                     {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                          'type': 'MDGContext'}},
                                      'args': [('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as a double',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'ctx': ['const',
                                                                 '&']},
                                      'types': {'ctx': 'MDGContext'}}],
                        'asFloat': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as a float',
                                                    'qualifiers': [],
                                                    'type': 'float'},
                                     'returnType': 'float',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx',
                                               'MDGContext',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as a float',
                                                    'qualifiers': [],
                                                    'type': 'float'},
                                     'returnType': 'float',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                        'ctx': ['const',
                                                                '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asInt': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                   'inArgs': [],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'Value of plug as an int',
                                                  'qualifiers': [],
                                                  'type': 'int'},
                                   'returnType': 'int',
                                   'static': False,
                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                   'types': {}},
                                  {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                       'type': 'MDGContext'}},
                                   'args': [('ctx', 'MDGContext', 'in')],
                                   'defaults': {},
                                   'deprecated': True,
                                   'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                   'inArgs': ['ctx'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'Value of plug as an int',
                                                  'qualifiers': [],
                                                  'type': 'int'},
                                   'returnType': 'int',
                                   'static': False,
                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                      'ctx': ['const',
                                                              '&']},
                                   'types': {'ctx': 'MDGContext'}}],
                        'asInt64': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as an int',
                                                    'qualifiers': [],
                                                    'type': 'MInt64'},
                                     'returnType': 'MInt64',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx',
                                               'MDGContext',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as an int',
                                                    'qualifiers': [],
                                                    'type': 'MInt64'},
                                     'returnType': 'MInt64',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                        'ctx': ['const',
                                                                '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asMAngle': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as an MAngle',
                                                     'qualifiers': [],
                                                     'type': 'MAngle'},
                                      'returnType': 'MAngle',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}},
                                     {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                          'type': 'MDGContext'}},
                                      'args': [('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as an MAngle',
                                                     'qualifiers': [],
                                                     'type': 'MAngle'},
                                      'returnType': 'MAngle',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'ctx': ['const',
                                                                 '&']},
                                      'types': {'ctx': 'MDGContext'}}],
                        'asMDataHandle': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Value of plug as an MDataHandle. When done using the returned handle, the caller must destroy it using MPlug::destructHandle().',
                                                          'qualifiers': [],
                                                          'type': 'MDataHandle'},
                                           'returnType': 'MDataHandle',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}},
                                          {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                               'type': 'MDGContext'}},
                                           'args': [('ctx',
                                                     'MDGContext',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                           'inArgs': ['ctx'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Value of plug as an MDataHandle. When done using the returned handle, the caller must destroy it using MPlug::destructHandle().',
                                                          'qualifiers': [],
                                                          'type': 'MDataHandle'},
                                           'returnType': 'MDataHandle',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                              'ctx': ['const',
                                                                      '&']},
                                           'types': {'ctx': 'MDGContext'}}],
                        'asMDistance': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Value of plug as an MDistance',
                                                        'qualifiers': [],
                                                        'type': 'MDistance'},
                                         'returnType': 'MDistance',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}},
                                        {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                             'type': 'MDGContext'}},
                                         'args': [('ctx',
                                                   'MDGContext',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': True,
                                         'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                         'inArgs': ['ctx'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Value of plug as an MDistance',
                                                        'qualifiers': [],
                                                        'type': 'MDistance'},
                                         'returnType': 'MDistance',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'ctx': ['const',
                                                                    '&']},
                                         'types': {'ctx': 'MDGContext'}}],
                        'asMObject': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Value of plug as an MObject',
                                                      'qualifiers': [],
                                                      'type': 'MObject'},
                                       'returnType': 'MObject',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}},
                                      {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                           'type': 'MDGContext'}},
                                       'args': [('ctx',
                                                 'MDGContext',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': True,
                                       'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                       'inArgs': ['ctx'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Value of plug as an MObject',
                                                      'qualifiers': [],
                                                      'type': 'MObject'},
                                       'returnType': 'MObject',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                          'ctx': ['const',
                                                                  '&']},
                                       'types': {'ctx': 'MDGContext'}}],
                        'asMTime': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as an MTime',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx',
                                               'MDGContext',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as an MTime',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                        'ctx': ['const',
                                                                '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asShort': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as a short',
                                                    'qualifiers': [],
                                                    'type': 'short'},
                                     'returnType': 'short',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx',
                                               'MDGContext',
                                               'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as a short',
                                                    'qualifiers': [],
                                                    'type': 'short'},
                                     'returnType': 'short',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*'],
                                                        'ctx': ['const',
                                                                '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asString': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nRetrieve the value in the current evaluation context of the attribute this plug references.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as an MString',
                                                     'qualifiers': [],
                                                     'type': 'MString'},
                                      'returnType': 'MString',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}},
                                     {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug ',
                                                          'type': 'MDGContext'}},
                                      'args': [('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as an MString',
                                                     'qualifiers': [],
                                                     'type': 'MString'},
                                      'returnType': 'MString',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                         'ctx': ['const',
                                                                 '&']},
                                      'types': {'ctx': 'MDGContext'}}],
                        'attribute': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThis method returns the attribute that this plug refers to.',
                                       'inArgs': [],
                                       'inverse': ('setAttribute', False),
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The attribute that this plug refers to.',
                                                      'qualifiers': [],
                                                      'type': 'MObject'},
                                       'returnType': 'MObject',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                        'child': [{'argInfo': {'obj': {'doc': 'The child attribute. ',
                                                       'type': 'MObject'}},
                                   'args': [('obj', 'MObject', 'in')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nReturns a plug to a given attribute that is a child of this plug. This method is only valid for compound plugs.',
                                   'inArgs': ['obj'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'The child plug',
                                                  'qualifiers': [],
                                                  'type': 'MPlug'},
                                   'returnType': 'MPlug',
                                   'static': False,
                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                      'obj': ['&']},
                                   'types': {'obj': 'MObject'}},
                                  {'argInfo': {'index': {'doc': 'The index of the plug to be found ',
                                                         'type': 'uint'}},
                                   'args': [('index', 'uint', 'in')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nReturns a plug to a given attribute that is a child of this plug. This method is only valid for compound plugs.',
                                   'inArgs': ['index'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'The child plug',
                                                  'qualifiers': [],
                                                  'type': 'MPlug'},
                                   'returnType': 'MPlug',
                                   'static': False,
                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                      'index': ['unsigned']},
                                   'types': {'index': 'uint'}}],
                        'className': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns the name of this class.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': ['*'],
                                                      'type': 'char'},
                                       'returnType': 'char',
                                       'static': True,
                                       'typeQualifiers': {},
                                       'types': {}}],
                        'connectedTo': [{'argInfo': {'array': {'doc': 'Location for storing connected plugs (allocated by the caller) ',
                                                               'type': 'MPlugArray'},
                                                     'asDst': {'doc': 'Check connections with this plug as destination. If there are such connections, put them in array. ',
                                                               'type': 'bool'},
                                                     'asSrc': {'doc': 'Check connections with this plug as source. If there are such connections, put them in array. ',
                                                               'type': 'bool'}},
                                         'args': [('array',
                                                   'MPlugArray',
                                                   'in'),
                                                  ('asDst',
                                                   'bool',
                                                   'in'),
                                                  ('asSrc',
                                                   'bool',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method finds all of the plugs that this plug is connected with. This method will always produce the networked version of the connected plugs.',
                                         'inArgs': ['array',
                                                    'asDst',
                                                    'asSrc'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': ' true If the plug has connections as either source or destination. Note that the array is filled in only with the type of connecting plugs requested by asSrc and asDst. Therefore, the method could return true while the array has nothing in it if, for example, the plug has connections as source but the user passes asSrc = false to the method. The parameters asSrc and asDst have no effect on the boolean return value.  false If this plug has no connections  ',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'array': ['&'],
                                                            'asDst': [],
                                                            'asSrc': []},
                                         'types': {'array': 'MPlugArray',
                                                   'asDst': 'bool',
                                                   'asSrc': 'bool'}}],
                        'connectionByPhysicalIndex': [{'argInfo': {'index': {'doc': 'The physical array index of the plug to be found ',
                                                                             'type': 'uint'}},
                                                       'args': [('index',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method will find and return a connected plug with the given physical index for its connection. The index can range from 0 to  numConnectedElements()  - 1. This method varies from elementByPhysicalIndex in that elementByPhysicalIndex will return plugs pointing to all existing data in the datablock regardless of whether the plug is connected or not.',
                                                       'inArgs': ['index'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A plug with the given index',
                                                                      'qualifiers': [],
                                                                      'type': 'MPlug'},
                                                       'returnType': 'MPlug',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'index': ['unsigned']},
                                                       'types': {'index': 'uint'}}],
                        'constructHandle': [{'argInfo': {'mBlock': {'doc': '',
                                                                    'type': 'MDataBlock'}},
                                             'args': [('mBlock',
                                                       'MDataBlock',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis method returns a data handle constructed for this plug.',
                                             'inArgs': ['mBlock'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'MDataHandle'},
                                             'returnType': 'MDataHandle',
                                             'static': False,
                                             'typeQualifiers': {'mBlock': ['&']},
                                             'types': {'mBlock': 'MDataBlock'}}],
                        'destinations': [{'argInfo': {'theDestinations': {'doc': 'Location for storing connected plugs (allocated by the caller). The array is first cleared, then the destination plugs are added. ',
                                                                          'type': 'MPlugArray'}},
                                          'args': [('theDestinations',
                                                    'MPlugArray',
                                                    'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nIf this plug is a source, return the destination plugs connected to it.',
                                          'inArgs': [],
                                          'outArgs': [u'theDestinations'],
                                          'returnInfo': {'doc': 'Returns true if the plug has one or more destinations.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                             'theDestinations': ['&']},
                                          'types': {'theDestinations': 'MPlugArray'}}],
                        'destinationsWithConversions': [{'argInfo': {'theDestinations': {'doc': 'Location for storing connected plugs (allocated by the caller). The array is first cleared, then the destination plugs are added. ',
                                                                                         'type': 'MPlugArray'}},
                                                         'args': [('theDestinations',
                                                                   'MPlugArray',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nIf this plug is a source, return the destination plugs connected to it.',
                                                         'inArgs': [],
                                                         'outArgs': [u'theDestinations'],
                                                         'returnInfo': {'doc': 'Returns true if the plug has one or more destinations.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'theDestinations': ['&']},
                                                         'types': {'theDestinations': 'MPlugArray'}}],
                        'destructHandle': [{'argInfo': {'mHandle': {'doc': '',
                                                                    'type': 'MDataHandle'}},
                                            'args': [('mHandle',
                                                      'MDataHandle',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method destructs the data handle for this plug. \r\n',
                                            'inArgs': ['mHandle'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'mHandle': ['&']},
                                            'types': {'mHandle': 'MDataHandle'}}],
                        'elementByLogicalIndex': [{'argInfo': {'index': {'doc': 'The index of the plug to be found ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method will find and return a plug with the given logical index. The logical index is the sparse array index used in MEL scripts. If a plug does not exist at the given Index, Maya will create a plug at that index. This is not the case with  elementByPhysicalIndex() . If needed, elementByLogicalIndex can be used to expand an array plug on a node. It is important to note that Maya assumes that all such plugs serve a purpose and it will not free non-networked plugs that result from such an array expansion.',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'A plug with the given index',
                                                                  'qualifiers': [],
                                                                  'type': 'MPlug'},
                                                   'returnType': 'MPlug',
                                                   'static': False,
                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                      'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                        'elementByPhysicalIndex': [{'argInfo': {'index': {'doc': 'The physical array index of the plug to be found ',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis method will find and return a plug with the given physical index. The index can range from 0 to  numElements()  - 1. This function is particularly useful for iteration through the element plugs of an array plug. It is equivalent to operator [] (int) This method is only valid for array plugs.',
                                                    'inArgs': ['index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'A plug with the given index',
                                                                   'qualifiers': [],
                                                                   'type': 'MPlug'},
                                                    'returnType': 'MPlug',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'index': ['unsigned']},
                                                    'types': {'index': 'uint'}}],
                        'evaluateNumElements': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the total number of elements in the datablock of this array plug. The return count will include both connected and non-connected elements, and will perform an evaluate in order to make sure that the datablock is as up-to-date as possible since some nodes do not place array elements into the datablock until the attribute is evaluated.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Total number of elements',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                        'getExistingArrayAttributeIndices': [{'argInfo': {'indices': {'doc': 'A list to store the logical indices of the set/connected elements. ',
                                                                                      'type': 'MIntArray'}},
                                                              'args': [(u'indices',
                                                                        'MIntArray',
                                                                        u'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nThis method will return a list of the logical indices of the elements in an array attribute that are either connected or have had their value set. This method is useful when the logical indices of connected/set elements are sparse.',
                                                              'inArgs': [],
                                                              'outArgs': [u'indices'],
                                                              'returnInfo': {'doc': 'The number of set/connected elements',
                                                                             'qualifiers': [],
                                                                             'type': 'int'},
                                                              'returnType': 'int',
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'indices': ['&']},
                                                              'types': {'indices': 'MIntArray'}}],
                        'getSetAttrCmds': [{'argInfo': {'cmds': {'doc': 'Array of strings in which the setAttr commands are to be returned.   ',
                                                                 'type': 'MStringArray'},
                                                        'useLongNames': {'doc': 'Normally, the returned commands will use the short names for flags and attributes. If this parameter is true then their long names will be used instead. (default: false)',
                                                                         'type': 'bool'},
                                                        'valueSelector': {'doc': '" cellpadding="3">\r  kAll- return setAttr commands for the plug and its children, regardless of their values.    kNonDefault- only return setAttr commands for the plug or its children if they are not at their default values.    kChanged- for nodes from referenced files, setAttr commands are only returned if the plug or one of its children has changed since its file was loaded. For all other nodes, the behaviour is the same a kNonDefault.   Note that if the plug is compound and one of its children has changed, then setAttrs will be generated for *all* of its children, even those which have not changed. \r  (default: kAll)   ',
                                                                          'type': ('MPlug',
                                                                                   'MValueSelector')}},
                                            'args': [('cmds',
                                                      'MStringArray',
                                                      'out'),
                                                     ('valueSelector',
                                                      ('MPlug',
                                                       'MValueSelector'),
                                                      'in'),
                                                     ('useLongNames',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'useLongNames': False,
                                                         'valueSelector': ('MPlug',
                                                                           'MValueSelector',
                                                                           'kAll')},
                                            'deprecated': False,
                                            'doc': '\r\nReturns an array of strings containing  setAttr  commands for this plug and all of its descendent plugs.',
                                            'inArgs': ['valueSelector',
                                                       'useLongNames'],
                                            'outArgs': ['cmds'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'cmds': ['&'],
                                                               'useLongNames': [],
                                                               'valueSelector': []},
                                            'types': {'cmds': 'MStringArray',
                                                      'useLongNames': 'bool',
                                                      'valueSelector': ('MPlug',
                                                                        'MValueSelector')}}],
                        'getValue': [{'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'MObject'}},
                                      'args': [('val', 'MObject', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MObject'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'MDataHandle'}},
                                      'args': [('val',
                                                'MDataHandle',
                                                'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MDataHandle'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'double'}},
                                      'args': [('val', 'double', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'double'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'float'}},
                                      'args': [('val', 'float', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'float'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'MInt64'}},
                                      'args': [('val', 'MInt64', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MInt64'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'int'}},
                                      'args': [('val', 'int', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'int'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'short'}},
                                      'args': [('val', 'short', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'short'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'bool'}},
                                      'args': [('val', 'bool', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'bool'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'MDistance'}},
                                      'args': [('val',
                                                'MDistance',
                                                'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MDistance'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'MAngle'}},
                                      'args': [('val', 'MAngle', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MAngle'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'MTime'}},
                                      'args': [('val', 'MTime', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MTime'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'char'}},
                                      'args': [('val', 'char', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'char'}},
                                     {'argInfo': {'val': {'doc': 'Storage for the attribute value',
                                                          'type': 'MString'}},
                                      'args': [('val', 'MString', 'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MString'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MObject'}},
                                      'args': [('val', 'MObject', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'MObject'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MDataHandle'}},
                                      'args': [('val',
                                                'MDataHandle',
                                                'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'MDataHandle'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'double'}},
                                      'args': [('val', 'double', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'double'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'float'}},
                                      'args': [('val', 'float', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'float'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MInt64'}},
                                      'args': [('val', 'MInt64', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'MInt64'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'int'}},
                                      'args': [('val', 'int', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'int'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'short'}},
                                      'args': [('val', 'short', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'short'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'bool'}},
                                      'args': [('val', 'bool', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'bool'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MDistance'}},
                                      'args': [('val',
                                                'MDistance',
                                                'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'MDistance'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MAngle'}},
                                      'args': [('val', 'MAngle', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'MAngle'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MTime'}},
                                      'args': [('val', 'MTime', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'MTime'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'char'}},
                                      'args': [('val', 'char', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'char'}},
                                     {'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MString'}},
                                      'args': [('val', 'MString', 'out'),
                                               ('ctx',
                                                'MDGContext',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': '\n This method is obsolete.  [From Maya 2018] \r\n',
                                      'inArgs': ['ctx'],
                                      'inverse': ('setValue', False),
                                      'outArgs': ['val'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['&'],
                                                         'val': ['&']},
                                      'types': {'ctx': 'MDGContext',
                                                'val': 'MString'}}],
                        'info': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nThis method returns a string containing the name of the node this plug belongs to and the attributes that the plug refers to. The string is of the form dependNode:atr1.atr2[].attr3 ...',
                                  'inArgs': [],
                                  'outArgs': [],
                                  'returnInfo': {'doc': 'Returns a string containing dependency node and attribute information for this plug.',
                                                 'qualifiers': [],
                                                 'type': 'MString'},
                                  'returnType': 'MString',
                                  'static': False,
                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                  'types': {}}],
                        'isArray': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nThis method determines if the plug is an array plug. Array plugs refer to array attributes and contain element plugs.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': ' true  false  ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}}],
                        'isCachingFlagSet': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns true if this plug or its attribute has its caching flag set.',
                                              'inArgs': [],
                                              'inverse': ('setCaching',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': ' true caching flag has been set  false caching flag has not been set  ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                        'isChannelBoxFlagSet': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if this plug or its attribute has its channel box flag set. Attributes will appear in the channel box if their channel box flag is set or if they are keyable.',
                                                 'inArgs': [],
                                                 'inverse': ('setChannelBox',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true channel box flag has been set  false channel box flag has not been set  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*']},
                                                 'types': {}}],
                        'isChild': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': "\r\nThis method determines if the plug is a child plug. A child plug's parent is always a compound plug.",
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': ' true  false  ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                     'types': {}}],
                        'isCompound': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThis method determines if the plug is a compound plug. Compound plugs refer to compound attributes and have child plugs.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': ' true  false  ',
                                                       'qualifiers': [],
                                                       'type': 'bool'},
                                        'returnType': 'bool',
                                        'static': False,
                                        'typeQualifiers': {'ReturnStatus': ['*']},
                                        'types': {}}],
                        'isConnected': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nDetermines if this plug is connected to one or more plugs.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': ' true If this plug is connected to another plug  false If this plug is not connected to another plug  ',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                        'isDefaultValue': [{'argInfo': {'forceEval': {'doc': 'Evaluate the plug prior to test. ',
                                                                      'type': 'bool'}},
                                            'args': [('forceEval',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'forceEval': True},
                                            'deprecated': False,
                                            'doc': "\r\nThis method determines if the plug value is equivalent to the plug's default value.",
                                            'inArgs': ['forceEval'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'forceEval': []},
                                            'types': {'forceEval': 'bool'}}],
                        'isDestination': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nDetermines if this plug is connected as a destination.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': ' true  plug is connected as a destination  false  plug is not connected as a destination  ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                           'types': {}}],
                        'isDynamic': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nDetermines whether the attribute is of dynamic type or not.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': ' true If the attribute is dynamic  false If this attribute is not added by user.  ',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                        'isElement': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThis method determines if the plug is an element plug. Element plugs refer to array attributes and are members of array plugs.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': ' true  false  ',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                        'isFreeToChange': [{'argInfo': {'checkChildren': {'doc': 'Check child plugs. ',
                                                                          'type': 'bool'},
                                                        'checkParents': {'doc': 'Check parent plugs. ',
                                                                         'type': 'bool'}},
                                            'args': [('checkParents',
                                                      'bool',
                                                      'in'),
                                                     ('checkChildren',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'checkChildren': True,
                                                         'checkParents': True},
                                            'deprecated': False,
                                            'doc': "\r\nReturns true if the plug's value is allowed to be set directly. A plug isFreeToChange if it is not locked, and it is not a destination or if it is a destination, then it must be a special case (such as connected to an anim curve).",
                                            'inArgs': ['checkParents',
                                                       'checkChildren'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': ' kFreeToChange All tested plugs are free to change.  kNotFreeToChange Some of the tested plugs are not free to change.  kChildrenNotFreeToChange Some of the children are not free to change.  ',
                                                           'qualifiers': [],
                                                           'type': ('MPlug',
                                                                    'FreeToChangeState')},
                                            'returnType': ('MPlug',
                                                           'FreeToChangeState'),
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                               'checkChildren': [],
                                                               'checkParents': []},
                                            'types': {'checkChildren': 'bool',
                                                      'checkParents': 'bool'}}],
                        'isFromReferencedFile': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method determines whether this plug came from a referenced file. A plug is considered to have come from a referenced file if it is connected and that connection was made within a referenced file.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': ' true plug was created within a referenced file  false plug was created within the current scene  ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                        'isIgnoredWhenRendering': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDetermines whether a connection to the attribute should be ignored during rendering.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': ' true If connected, the attribute should be ingored during rendering.  false If connected, the attribute should not be ingored during rendering.  ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                        'isKeyable': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nDetermines if this plug is keyable. The default keyability of a plug is determined by its attribute, and can be retrieved using  MFnAttribute::isKeyable . Keyable plugs will be keyed by AutoKey and the Set Keyframe UI. Non-keyable plugs prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.',
                                       'inArgs': [],
                                       'inverse': ('setKeyable', False),
                                       'outArgs': [],
                                       'returnInfo': {'doc': ' true If this plug is keyable  false If this plug is not keyable  ',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                       'types': {}}],
                        'isLocked': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\r\nDetermines the locked state of this plug's value. A plug's locked state determines whether or not the plug's value can be changed.",
                                      'inArgs': [],
                                      'inverse': ('setLocked', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': " true If this plug's value is locked  false If this plug's value is not locked  ",
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                        'isNetworked': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThis method determines if the plug is networked or non-networked.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': ' true  false  ',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                        'isNull': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nThis method determines whether this plug is valid. A plug is valid if it refers to an attribute.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': ' true this plug is not valid  false this plug is valid  ',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                    'types': {}}],
                        'isProcedural': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nThis method determines if the plug is a procedural plug. A procedural plug is one which is created by Maya's internal procedures or by the nodes themselves and which should not be saved to or restored from files.",
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true  false  ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                        'isSource': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nDetermines if this plug is connected as a source.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': ' true  plug is connected as a source  false  plug is not connected as a source  ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                      'types': {}}],
                        'logicalIndex': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the logical index of the element this plug refers to. The logical index is a sparse index, equivalent to the array index used in MEL.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The logical array index of the element this plug refers to',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {'ReturnStatus': ['*']},
                                          'types': {}}],
                        'name': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': "\r\nReturns the name of this plug in the form  'nodeName.attributeName' .",
                                  'inArgs': [],
                                  'outArgs': [],
                                  'returnInfo': {'doc': 'The name of this node',
                                                 'qualifiers': [],
                                                 'type': 'MString'},
                                  'returnType': 'MString',
                                  'static': False,
                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                  'types': {}}],
                        'node': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nReturns the dependency node that this plug belongs to.',
                                  'inArgs': [],
                                  'outArgs': [],
                                  'returnInfo': {'doc': "A pointer to this plug's dependency node.",
                                                 'qualifiers': [],
                                                 'type': 'MObject'},
                                  'returnType': 'MObject',
                                  'static': False,
                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                  'types': {}}],
                        'numChildren': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the total number of children of this compound plug.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Total number of children',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                        'numConnectedChildren': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the number of children of this plug that are connected in the dependency graph.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Total number of children',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                        'numConnectedElements': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the total number of connected element plugs belonging to this array plug.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Total number of elements',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                        'numElements': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the total number of elements in the datablock of this array plug. The return count will include all existing non-connected elements plus connected elements if they have been evaluated. It will not include connected elements that have not yet been placed into the datablock. The method  MPlug::evaluateNumElements  can be used in the sitution where you want an accurate count that includes all connected elements.',
                                         'inArgs': [],
                                         'inverse': ('setNumElements',
                                                     False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Total number of elements',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                        'parent': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nReturns the parent plug. The parent plug will always be a compound plug. This method is only valid for networked child plugs.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'The parent of this plug.',
                                                   'qualifiers': [],
                                                   'type': 'MPlug'},
                                    'returnType': 'MPlug',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                    'types': {}}],
                        'partialName': [{'argInfo': {'includeInstancedIndices': {'doc': "If the plug's attribute is an element of an instanced multi, then setting this parameter true will cause the array index to be included in the returned string. For example, if you are planning to append the returned plug name to a node's dagPath, then the instance index is unnecessary as it can be determined from the dagPath. (default: false)",
                                                                                 'type': 'bool'},
                                                     'includeNodeName': {'doc': "If true, then the plug's node name is prefixed to the name of the plug, with a dot separating it from the attribute name. If false, then just the attribute name is returned. (default: false)",
                                                                         'type': 'bool'},
                                                     'includeNonMandatoryIndices': {'doc': "If the plug's attribute is a non-instanced element of a multi which is NOT marked as indexMatters, then setting this parameter true will cause its index to be included in the returned string anyway. \r  If the attribute is marked as indexMatters then its array index will be included regardless of the setting of this parameter. \r  If the attribute is instanced then it is not affected by this parameter. See the next parameter instead. (default: false)",
                                                                                    'type': 'bool'},
                                                     'useAlias': {'doc': 'Display aliased name if alias exists. (default: false)',
                                                                  'type': 'bool'},
                                                     'useFullAttributePath': {'doc': "Normally, the plug's attribute path is compressed so that any compound ancestors which do not serve to uniquely identify the plug are removed. Setting this parameter true will cause the full attribute path to be used. (default: false)",
                                                                              'type': 'bool'},
                                                     'useLongNames': {'doc': 'Normally, short attribute names are used. Setting this true will cause long names to be used. (default: false)',
                                                                      'type': 'bool'}},
                                         'args': [('includeNodeName',
                                                   'bool',
                                                   'in'),
                                                  ('includeNonMandatoryIndices',
                                                   'bool',
                                                   'in'),
                                                  ('includeInstancedIndices',
                                                   'bool',
                                                   'in'),
                                                  ('useAlias',
                                                   'bool',
                                                   'in'),
                                                  ('useFullAttributePath',
                                                   'bool',
                                                   'in'),
                                                  ('useLongNames',
                                                   'bool',
                                                   'in')],
                                         'defaults': {'includeInstancedIndices': False,
                                                      'includeNodeName': False,
                                                      'includeNonMandatoryIndices': False,
                                                      'useAlias': False,
                                                      'useFullAttributePath': False,
                                                      'useLongNames': False},
                                         'deprecated': False,
                                         'doc': '\r\nBy default, this method returns the shortest possible name for the plug, but its parameters can be used to add parts back in.',
                                         'inArgs': ['includeNodeName',
                                                    'includeNonMandatoryIndices',
                                                    'includeInstancedIndices',
                                                    'useAlias',
                                                    'useFullAttributePath',
                                                    'useLongNames'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The name of the plug.',
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                            'includeInstancedIndices': [],
                                                            'includeNodeName': [],
                                                            'includeNonMandatoryIndices': [],
                                                            'useAlias': [],
                                                            'useFullAttributePath': [],
                                                            'useLongNames': []},
                                         'types': {'includeInstancedIndices': 'bool',
                                                   'includeNodeName': 'bool',
                                                   'includeNonMandatoryIndices': 'bool',
                                                   'useAlias': 'bool',
                                                   'useFullAttributePath': 'bool',
                                                   'useLongNames': 'bool'}}],
                        'selectAncestorLogicalIndex': [{'argInfo': {'attribute': {'doc': 'array attribute whose index will be changed',
                                                                                  'type': 'MObject'},
                                                                    'index': {'doc': 'index value to be set ',
                                                                              'type': 'uint'}},
                                                        'args': [('index',
                                                                  'uint',
                                                                  'in'),
                                                                 ('attribute',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {'attribute': 'MObject::kNullObj'},
                                                        'deprecated': False,
                                                        'doc': "\r\nThis method is a convenience routine to allow quick iteration and construction of plugs with array plugs in their ancestry. It selects a plug into the current object by changing an ancestor array's logical index.",
                                                        'inArgs': ['index',
                                                                   'attribute'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'attribute': ['const',
                                                                                         '&'],
                                                                           'index': ['unsigned']},
                                                        'types': {'attribute': 'MObject',
                                                                  'index': 'uint'}}],
                        'setAttribute': [{'argInfo': {'attribute': {'doc': 'attribute to change the plug to',
                                                                    'type': 'MObject'}},
                                          'args': [('attribute',
                                                    'MObject',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThis method is a convenience routine to allow quick movement between attributes on a single node. If the current plug is a networked plug, it becomes a new non-networked plug referring to the requested attribute. If the current plug is a non-networked plug, it is changed to refer to the requested attribute.',
                                          'inArgs': ['attribute'],
                                          'inverse': ('attribute', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'attribute': ['&']},
                                          'types': {'attribute': 'MObject'}}],
                        'setBool': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                         'type': 'bool'}},
                                     'args': [('val', 'bool', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nSet the current value of the attribute this plug references.',
                                     'inArgs': ['val'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'val': []},
                                     'types': {'val': 'bool'}}],
                        'setCaching': [{'argInfo': {'isCaching': {'doc': 'True if this plug should be cached',
                                                                  'type': 'bool'}},
                                        'args': [('isCaching',
                                                  'bool',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets whether this plug is cached internally. Note: turning caching on for a plug will force the plug to become networked. Network plugs take longer to look up in the DG; therefore you should only make a plug cached only if you are certain that the network plug look-up will take less than the saved evaluation cost.',
                                        'inArgs': ['isCaching'],
                                        'inverse': ('isCachingFlagSet',
                                                    True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'isCaching': []},
                                        'types': {'isCaching': 'bool'}}],
                        'setChannelBox': [{'argInfo': {'inChannelBox': {'doc': 'True if this plug should be displayed in the channel box',
                                                                        'type': 'bool'}},
                                           'args': [('inChannelBox',
                                                     'bool',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSets whether this plug is displayed in the channel box. This overrides the default display of a plug set with  MFnAttribute::setChannelBox . Keyable attributes are always shown in the channel box so this flag is ignored on keyable plugs.',
                                           'inArgs': ['inChannelBox'],
                                           'inverse': ('isChannelBoxFlagSet',
                                                       True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'inChannelBox': []},
                                           'types': {'inChannelBox': 'bool'}}],
                        'setChar': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                         'type': 'char'}},
                                     'args': [('val', 'char', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nSet the current value of the attribute this plug references.',
                                     'inArgs': ['val'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'val': []},
                                     'types': {'val': 'char'}}],
                        'setDouble': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                           'type': 'double'}},
                                       'args': [('val', 'double', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSet the current value of the attribute this plug references.',
                                       'inArgs': ['val'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'val': []},
                                       'types': {'val': 'double'}}],
                        'setFloat': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'float'}},
                                      'args': [('val', 'float', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSet the current value of the attribute this plug references.',
                                      'inArgs': ['val'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'float'}}],
                        'setInt': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                        'type': 'int'}},
                                    'args': [('val', 'int', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nSet the current value of the attribute this plug references.',
                                    'inArgs': ['val'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {'val': []},
                                    'types': {'val': 'int'}}],
                        'setInt64': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MInt64'}},
                                      'args': [('val', 'MInt64', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSet the current value of the attribute this plug references.',
                                      'inArgs': ['val'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'MInt64'}}],
                        'setKeyable': [{'argInfo': {'keyable': {'doc': 'True if this plug should be keyable',
                                                                'type': 'bool'}},
                                        'args': [('keyable',
                                                  'bool',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThis overrides the default keyability of a plug set with  MFnAttribute::setKeyable . Keyable plugs will be keyed by AutoKey and the Set Keyframe UI. Non-keyable plugs prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.',
                                        'inArgs': ['keyable'],
                                        'inverse': ('isKeyable', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'keyable': []},
                                        'types': {'keyable': 'bool'}}],
                        'setLocked': [{'argInfo': {'locked': {'doc': "True if this plug's value is to be locked",
                                                              'type': 'bool'}},
                                       'args': [('locked', 'bool', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': "\r\nSets the locked state for this plug's value. A plug's locked state determines whether or not the plug's value can be changed.",
                                       'inArgs': ['locked'],
                                       'inverse': ('isLocked', True),
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'locked': []},
                                       'types': {'locked': 'bool'}}],
                        'setMAngle': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                           'type': 'MAngle'}},
                                       'args': [('val', 'MAngle', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSet the current value of the attribute this plug references.',
                                       'inArgs': ['val'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'val': ['&']},
                                       'types': {'val': 'MAngle'}}],
                        'setMDataHandle': [{'argInfo': {'handle': {'doc': 'The handle containing the data to which the attribute will be set',
                                                                   'type': 'MDataHandle'}},
                                            'args': [('handle',
                                                      'MDataHandle',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\r\nSet the current value of the attribute this plug references with the values in the handle. This method is most useful when the plug is an array plug, and you've filled the handle with data. Sending the value using this version of setValue will set the handle's data into the datablock and send out the appropriate attributeChanged messages to update the UI related to the attribute.",
                                            'inArgs': ['handle'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'handle': ['&']},
                                            'types': {'handle': 'MDataHandle'}}],
                        'setMDistance': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                              'type': 'MDistance'}},
                                          'args': [('val',
                                                    'MDistance',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nSet the current value of the attribute this plug references.',
                                          'inArgs': ['val'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'val': ['&']},
                                          'types': {'val': 'MDistance'}}],
                        'setMObject': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                            'type': 'MObject'}},
                                        'args': [('val',
                                                  'MObject',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSet the current value of the attribute this plug references.',
                                        'inArgs': ['val'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'val': ['&']},
                                        'types': {'val': 'MObject'}}],
                        'setMPxData': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                            'type': 'MPxData'}},
                                        'args': [('val',
                                                  'MPxData',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSet the current value of the attribute this plug references.',
                                        'inArgs': ['val'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'val': ['*']},
                                        'types': {'val': 'MPxData'}}],
                        'setMTime': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MTime'}},
                                      'args': [('val', 'MTime', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSet the current value of the attribute this plug references.',
                                      'inArgs': ['val'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MTime'}}],
                        'setNumElements': [{'argInfo': {'elements': {'doc': 'new array size',
                                                                     'type': 'uint'}},
                                            'args': [('elements',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe method is used to pre-allocate the number of elements that an array plug will contain. The plug passed to this method must be an array plug and there must be no elements already allocated.',
                                            'inArgs': ['elements'],
                                            'inverse': ('numElements',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'elements': ['unsigned']},
                                            'types': {'elements': 'uint'}}],
                        'setShort': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'short'}},
                                      'args': [('val', 'short', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSet the current value of the attribute this plug references.',
                                      'inArgs': ['val'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'short'}}],
                        'setString': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                           'type': 'MString'}},
                                       'args': [('val', 'MString', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSet the current value of the attribute this plug references.',
                                       'inArgs': ['val'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'val': ['const',
                                                                  '&']},
                                       'types': {'val': 'MString'}}],
                        'setValue': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MObject'}},
                                      'args': [('val', 'MObject', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MObject'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MPxData'}},
                                      'args': [('val', 'MPxData', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['*']},
                                      'types': {'val': 'MPxData'}},
                                     {'argInfo': {'handle': {'doc': 'The handle containing the data to which the attribute will be set',
                                                             'type': 'MDataHandle'}},
                                      'args': [('handle',
                                                'MDataHandle',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['handle'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'handle': ['&']},
                                      'types': {'handle': 'MDataHandle'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'double'}},
                                      'args': [('val', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'double'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'float'}},
                                      'args': [('val', 'float', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'float'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MInt64'}},
                                      'args': [('val', 'MInt64', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'MInt64'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'int'}},
                                      'args': [('val', 'int', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'int'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'short'}},
                                      'args': [('val', 'short', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'short'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'bool'}},
                                      'args': [('val', 'bool', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'bool'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MDistance'}},
                                      'args': [('val',
                                                'MDistance',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MDistance'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MAngle'}},
                                      'args': [('val', 'MAngle', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MAngle'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MTime'}},
                                      'args': [('val', 'MTime', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['&']},
                                      'types': {'val': 'MTime'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'char'}},
                                      'args': [('val', 'char', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': []},
                                      'types': {'val': 'char'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MString'}},
                                      'args': [('val', 'MString', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['const',
                                                                 '&']},
                                      'types': {'val': 'MString'}},
                                     {'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'char'}},
                                      'args': [('val', 'char', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['val'],
                                      'inverse': ('getValue', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'val': ['const',
                                                                 '*']},
                                      'types': {'val': 'char'}}],
                        'source': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nIf this plug is a destination, return the source plug connected to it. If this plug is not a destination, a null plug is returned.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Source plug, or null plug if not a destination.',
                                                   'qualifiers': [],
                                                   'type': 'MPlug'},
                                    'returnType': 'MPlug',
                                    'static': False,
                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                    'types': {}}],
                        'sourceWithConversion': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nIf this plug is a destination, return the source plug connected to it.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Source plug, or null plug if not a destination.',
                                                                 'qualifiers': [],
                                                                 'type': 'MPlug'},
                                                  'returnType': 'MPlug',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}]},
            'pymelEnums': {'FreeToChangeState': "Enum('FreeToChangeState', [('freeToChange', 0), ('kFreeToChange', 0), ('notFreeToChange', 1), ('kNotFreeToChange', 1), ('childrenNotFreeToChange', 2), ('kChildrenNotFreeToChange', 2)], multiKeys=True)",
                           'MValueSelector': "Enum('MValueSelector', [('all', 0), ('kAll', 0), ('nonDefault', 1), ('kNonDefault', 1), ('changed', 2), ('kChanged', 2), ('lastAttrSelector', 3), ('kLastAttrSelector', 3)], multiKeys=True)"},
            'pymelMethods': {'attribute': 'getAttribute',
                             'numElements': 'getNumElements'}},
  'MPlugArray': {'enums': {},
                 'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                 ('setLength', 'length')],
                 'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the indicated element ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MPlug'},
                                              'returnType': 'MPlug',
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned']},
                                              'types': {'index': 'uint'}},
                                             {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the indicated element ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MPlug'},
                                              'returnType': 'MPlug',
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned']},
                                              'types': {'index': 'uint'}}],
                             'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                 'type': 'MPlug'}},
                                         'args': [('element',
                                                   'MPlug',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                         'inArgs': ['element'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'element': ['const',
                                                                        '&']},
                                         'types': {'element': 'MPlug'}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'clear': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                             'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                              'type': 'MPlugArray'}},
                                       'args': [('source',
                                                 'MPlugArray',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the contents of the source array to this array.',
                                       'inArgs': ['source'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'source': ['const',
                                                                     '&']},
                                       'types': {'source': 'MPlugArray'}}],
                             'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                            'type': 'MPlug__array'}},
                                      'args': [('array',
                                                'MPlug__array',
                                                'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': [],
                                      'outArgs': ['array'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'array': []},
                                      'types': {'array': 'MPlug__array'}}],
                             'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                 'type': 'MPlug'},
                                                     'index': {'doc': 'the index of the element to set to the the new value',
                                                               'type': 'uint'}},
                                         'args': [('element',
                                                   'MPlug',
                                                   'in'),
                                                  ('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                         'inArgs': ['element', 'index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'element': ['const',
                                                                        '&'],
                                                            'index': ['unsigned']},
                                         'types': {'element': 'MPlug',
                                                   'index': 'uint'}}],
                             'length': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the number of elements in the instance.',
                                         'inArgs': [],
                                         'inverse': ('setLength', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of elements in the instance ',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                               'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                         'inArgs': ['index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'index': ['unsigned']},
                                         'types': {'index': 'uint'}}],
                             'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                              'type': 'MPlug'},
                                                  'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                            'type': 'uint'}},
                                      'args': [('element',
                                                'MPlug',
                                                'in'),
                                               ('index', 'uint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSets the value of the indicated element to the indicated  MPlug  value.',
                                      'inArgs': ['element', 'index'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'element': ['const',
                                                                     '&'],
                                                         'index': ['unsigned']},
                                      'types': {'element': 'MPlug',
                                                'index': 'uint'}}],
                             'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                   'type': 'uint'}},
                                            'args': [('length',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                            'inArgs': ['length'],
                                            'inverse': ('length', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'length': ['unsigned']},
                                            'types': {'length': 'uint'}}],
                             'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                'type': 'uint'}},
                                                   'args': [('newIncrement',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                   'inArgs': ['newIncrement'],
                                                   'inverse': ('sizeIncrement',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'newIncrement': ['unsigned']},
                                                   'types': {'newIncrement': 'uint'}}],
                             'sizeIncrement': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                'inArgs': [],
                                                'inverse': ('setSizeIncrement',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'length': 'getLength',
                                  'sizeIncrement': 'getSizeIncrement'}},
  'MPoint': {'enums': {},
             'methods': {'[static]': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nA constant representing the origin - (0,0,0,1). \r\n  Reprocessed example  \n Examples: \n \n   \n apiMeshCreator.cpp ,  clusterWeightFunction.cpp ,  instancerListCmd.cpp ,  lineManip.cpp ,  lineManipContainer.cpp ,  squareScaleManip.cpp , and  squareScaleManipContext.cpp . \n \n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': ['MPoint::origin'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': True,
                                       'typeQualifiers': {},
                                       'types': {}}],
                         '__add__': [{'argInfo': {'other': {'doc': 'Vector to add.',
                                                            'type': 'MVector'}},
                                      'args': [('other',
                                                'MVector',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe addition operator for adding an  MVector  to an  MPoint . A new point is returned whose position is that of the original point translated by the vector.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MVector'}}],
                         '__div__': [{'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                            'type': 'double'}},
                                      'args': [('scale', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe division operator that allows the vector to by scaled by the given double parameter. The x, y, and z components are each divided by the parameter. The w component remains unchanged.',
                                      'inArgs': ['scale'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'scale': ['const']},
                                      'types': {'scale': 'double'}}],
                         '__eq__': [{'argInfo': {'other': {'doc': 'Point to compare with.',
                                                           'type': 'MPoint'}},
                                     'args': [('other', 'MPoint', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nThe equality operator.',
                                     'inArgs': ['other'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'True if all of the x, y, z and w components of the two points are identical. ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'other': ['const',
                                                                  '&']},
                                     'types': {'other': 'MPoint'}}],
                         '__getitem__': [{'argInfo': {'i': {'doc': 'Value indicating which component to return.',
                                                            'type': 'uint'}},
                                          'args': [('i', 'uint', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThe index operator.  \n If the argument is 0 it will return the x component of the constant instance.  \n If the argument is 1 it will return the y component of the constant instance.  \n If the argument is 2 it will return the z component of the constant instance.  \n If the argument is 3 it will return the w component of the constant instance.  \n Otherwise it will return the x component of the point. \n \n Parameters: \n \n [in]  i  Value indicating which component to return. \n \n \n Returns: The value of the indicated component of the instance.  \n',
                                          'inArgs': ['i'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The value of the indicated component of the instance. ',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'i': ['unsigned']},
                                          'types': {'i': 'uint'}},
                                         {'argInfo': {'i': {'doc': 'Value indicating which component to return.',
                                                            'type': 'uint'}},
                                          'args': [('i', 'uint', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                          'inArgs': ['i'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The value of the indicated component of the instance. ',
                                                         'qualifiers': ['&'],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {'i': ['unsigned']},
                                          'types': {'i': 'uint'}}],
                         '__iadd__': [{'argInfo': {'vector': {'doc': 'Vector to add.',
                                                              'type': 'MVector'}},
                                       'args': [('vector',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place addition operator for adding an  MVector  to an  MPoint . The current instance is translated from its original position by the vector.',
                                       'inArgs': ['vector'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A reference to the resulting point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'vector': ['const',
                                                                     '&']},
                                       'types': {'vector': 'MVector'}}],
                         '__imul__': [{'argInfo': {'right': {'doc': 'the MMatrix to right multiply by',
                                                             'type': 'MMatrix'}},
                                       'args': [('right',
                                                 'MMatrix',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place multiplication operator for computing the product of this point instance with the given matrix.',
                                       'inArgs': ['right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A point representing the product ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'right': ['const',
                                                                    '&']},
                                       'types': {'right': 'MMatrix'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                              'type': 'int'}},
                                       'args': [('factor', 'int', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                       'inArgs': ['factor'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'This point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'factor': ['const']},
                                       'types': {'factor': 'int'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                              'type': 'short'}},
                                       'args': [('factor',
                                                 'short',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                       'inArgs': ['factor'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'This point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'factor': ['const']},
                                       'types': {'factor': 'short'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                              'type': 'uint'}},
                                       'args': [('factor', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                       'inArgs': ['factor'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'This point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'factor': ['const',
                                                                     'unsigned']},
                                       'types': {'factor': 'uint'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                              'type': 'short'}},
                                       'args': [('factor',
                                                 'short',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                       'inArgs': ['factor'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'This point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'factor': ['const',
                                                                     'unsigned']},
                                       'types': {'factor': 'short'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                              'type': 'float'}},
                                       'args': [('factor',
                                                 'float',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                       'inArgs': ['factor'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'This point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'factor': ['const']},
                                       'types': {'factor': 'float'}},
                                      {'argInfo': {'factor': {'doc': 'Scalar to multiply this point by.',
                                                              'type': 'double'}},
                                       'args': [('factor',
                                                 'double',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place multiplication operator for computing the scalar product of this point instance with the given scalar.',
                                       'inArgs': ['factor'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'This point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'factor': ['const']},
                                       'types': {'factor': 'double'}}],
                         '__isub__': [{'argInfo': {'vector': {'doc': 'Vector to substract.',
                                                              'type': 'MVector'}},
                                       'args': [('vector',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe in-place subtraction operator for subtracting an  MVector  from an  MPoint . The current instance is translated from its original position by the inverse of the vector.',
                                       'inArgs': ['vector'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A reference to the resulting point. ',
                                                      'qualifiers': ['&'],
                                                      'type': 'MPoint'},
                                       'returnType': 'MPoint',
                                       'static': False,
                                       'typeQualifiers': {'vector': ['const',
                                                                     '&']},
                                       'types': {'vector': 'MVector'}}],
                         '__mul__': [{'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                            'type': 'int'}},
                                      'args': [('scale', 'int', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                      'inArgs': ['scale'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'scale': ['const']},
                                      'types': {'scale': 'int'}},
                                     {'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                            'type': 'short'}},
                                      'args': [('scale', 'short', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                      'inArgs': ['scale'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'scale': ['const']},
                                      'types': {'scale': 'short'}},
                                     {'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                            'type': 'uint'}},
                                      'args': [('scale', 'uint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                      'inArgs': ['scale'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'scale': ['const',
                                                                   'unsigned']},
                                      'types': {'scale': 'uint'}},
                                     {'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                            'type': 'short'}},
                                      'args': [('scale', 'short', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                      'inArgs': ['scale'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'scale': ['const',
                                                                   'unsigned']},
                                      'types': {'scale': 'short'}},
                                     {'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                            'type': 'float'}},
                                      'args': [('scale', 'float', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                      'inArgs': ['scale'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'scale': ['const']},
                                      'types': {'scale': 'float'}},
                                     {'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                            'type': 'double'}},
                                      'args': [('scale', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe multipication operator that allows the vector to by scaled by the given parameter. The x, y, and z components are each multiplied by the parameter. The w component remains unchanged.',
                                      'inArgs': ['scale'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'scale': ['const']},
                                      'types': {'scale': 'double'}},
                                     {'argInfo': {'right': {'doc': 'the MMatrix to right multiply by',
                                                            'type': 'MMatrix'}},
                                      'args': [('right',
                                                'MMatrix',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe multiplication operator for computing the product of this point instance with the given matrix.',
                                      'inArgs': ['right'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A point representing the product ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'right': ['const',
                                                                   '&']},
                                      'types': {'right': 'MMatrix'}},
                                     {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                        'type': 'MPoint'},
                                                  'scale': {'doc': 'The scale parameter. ',
                                                            'type': 'int'}},
                                      'args': [('scale', 'int', 'in'),
                                               ('p', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['scale', 'p'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                     'qualifiers': ['MPoint'],
                                                     'type': ('MPoint',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MPoint',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'p': ['const',
                                                               '&'],
                                                         'scale': []},
                                      'types': {'p': 'MPoint',
                                                'scale': 'int'}},
                                     {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                        'type': 'MPoint'},
                                                  'scale': {'doc': 'The scale parameter. ',
                                                            'type': 'short'}},
                                      'args': [('scale', 'short', 'in'),
                                               ('p', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['scale', 'p'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                     'qualifiers': ['MPoint'],
                                                     'type': ('MPoint',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MPoint',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'p': ['const',
                                                               '&'],
                                                         'scale': []},
                                      'types': {'p': 'MPoint',
                                                'scale': 'short'}},
                                     {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                        'type': 'MPoint'},
                                                  'scale': {'doc': 'The scale parameter. ',
                                                            'type': 'uint'}},
                                      'args': [('scale', 'uint', 'in'),
                                               ('p', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['scale', 'p'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                     'qualifiers': ['MPoint'],
                                                     'type': ('MPoint',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MPoint',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'p': ['const',
                                                               '&'],
                                                         'scale': ['unsigned']},
                                      'types': {'p': 'MPoint',
                                                'scale': 'uint'}},
                                     {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                        'type': 'MPoint'},
                                                  'scale': {'doc': 'The scale parameter. ',
                                                            'type': 'short'}},
                                      'args': [('scale', 'short', 'in'),
                                               ('p', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['scale', 'p'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                     'qualifiers': ['MPoint'],
                                                     'type': ('MPoint',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MPoint',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'p': ['const',
                                                               '&'],
                                                         'scale': ['unsigned']},
                                      'types': {'p': 'MPoint',
                                                'scale': 'short'}},
                                     {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                        'type': 'MPoint'},
                                                  'scale': {'doc': 'The scale parameter. ',
                                                            'type': 'float'}},
                                      'args': [('scale', 'float', 'in'),
                                               ('p', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['scale', 'p'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                     'qualifiers': ['MPoint'],
                                                     'type': ('MPoint',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MPoint',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'p': ['const',
                                                               '&'],
                                                         'scale': []},
                                      'types': {'p': 'MPoint',
                                                'scale': 'float'}},
                                     {'argInfo': {'p': {'doc': 'The point to be scaled.',
                                                        'type': 'MPoint'},
                                                  'scale': {'doc': 'The scale parameter. ',
                                                            'type': 'double'}},
                                      'args': [('scale', 'double', 'in'),
                                               ('p', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['scale', 'p'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': "A new point containing the value of 'p' scaled by 'scale'. ",
                                                     'qualifiers': ['MPoint'],
                                                     'type': ('MPoint',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MPoint',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'p': ['const',
                                                               '&'],
                                                         'scale': []},
                                      'types': {'p': 'MPoint',
                                                'scale': 'double'}},
                                     {'argInfo': {'left': {'doc': 'the MMatrix to right multiply by ',
                                                           'type': 'MMatrix'},
                                                  'right': {'doc': 'this point instance',
                                                            'type': 'MPoint'}},
                                      'args': [('left', 'MMatrix', 'in'),
                                               ('right', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                      'inArgs': ['left', 'right'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'A point representing the product ',
                                                     'qualifiers': ['MPoint'],
                                                     'type': ('MPoint',
                                                              'OPENMAYA_EXPORT')},
                                      'returnType': ('MPoint',
                                                     'OPENMAYA_EXPORT'),
                                      'static': False,
                                      'typeQualifiers': {'left': ['const',
                                                                  '&'],
                                                         'right': ['const',
                                                                   '&']},
                                      'types': {'left': 'MMatrix',
                                                'right': 'MPoint'}}],
                         '__ne__': [{'argInfo': {'other': {'doc': 'Point to compare with.',
                                                           'type': 'MPoint'}},
                                     'args': [('other', 'MPoint', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nThe inequality operator.',
                                     'inArgs': ['other'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'True if any of the x, y, z and w components of the two points are not identical. ',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'other': ['const',
                                                                  '&']},
                                     'types': {'other': 'MPoint'}}],
                         '__sub__': [{'argInfo': {'other': {'doc': 'The other point.',
                                                            'type': 'MPoint'}},
                                      'args': [('other', 'MPoint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe subtraction operator for two MPoints. The result is the  MVector  from the other point to this instance.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'MVector from the other point to this point ',
                                                     'qualifiers': [],
                                                     'type': 'MVector'},
                                      'returnType': 'MVector',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MPoint'}},
                                     {'argInfo': {'other': {'doc': 'Vector to substract.',
                                                            'type': 'MVector'}},
                                      'args': [('other',
                                                'MVector',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe addition operator for subtracting an  MVector  from an  MPoint . A new point is returned whose position is that of the original point translated by the inverse of the vector.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The resulting point. ',
                                                     'qualifiers': [],
                                                     'type': 'MPoint'},
                                      'returnType': 'MPoint',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MVector'}}],
                         'cartesianize': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nIf this point instance is of the form P(W*x, W*y, W*z, W), for some scale factor W != 0, then it is reset to be P(x, y, z, 1). This will only work correctly if the point is in homogenous form or cartesian form. If the point is in rational form, the results are not defined. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['&'],
                                                          'type': 'MPoint'},
                                           'returnType': 'MPoint',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['*'],
                                                       'type': 'char'},
                                        'returnType': 'char',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'distanceTo': [{'argInfo': {'other': {'doc': 'The point to compute the distance to.',
                                                               'type': 'MPoint'}},
                                         'args': [('other',
                                                   'MPoint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturn the distance between this instance and the point passed as an argument.',
                                         'inArgs': ['other'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The distance between the two points. ',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {'other': ['const',
                                                                      '&']},
                                         'types': {'other': 'MPoint'}}],
                         'get': [{'argInfo': {'dest': {'doc': 'The four element array of doubles.',
                                                       'type': 'double__array4'}},
                                  'args': [('dest',
                                            'double__array4',
                                            'out')],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nCopy the values of x, y, z, and w from the instance to the four elements of the given array of doubles.',
                                  'inArgs': [],
                                  'outArgs': ['dest'],
                                  'returnInfo': {'doc': '',
                                                 'qualifiers': [],
                                                 'type': None},
                                  'returnType': None,
                                  'static': False,
                                  'typeQualifiers': {'dest': []},
                                  'types': {'dest': 'double__array4'}},
                                 {'argInfo': {'dest': {'doc': 'The four element array of floats.',
                                                       'type': 'float__array4'}},
                                  'args': [('dest',
                                            'float__array4',
                                            'out')],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nCopy the values of x, y, z, and w from the instance to the four elements of the given array of floats.',
                                  'inArgs': [],
                                  'outArgs': ['dest'],
                                  'returnInfo': {'doc': '',
                                                 'qualifiers': [],
                                                 'type': None},
                                  'returnType': None,
                                  'static': False,
                                  'typeQualifiers': {'dest': []},
                                  'types': {'dest': 'float__array4'}}],
                         'homogenize': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nIf this point instance is of the form P(x, y, z, W) (ie. is in rational or (for W==1) cartesian form), for some scale factor W != 0, then it is reset to be P(W*x, W*y, W*z, W). \r\n  Reprocessed example  \n Examples: \n \n   \n apiMeshShapeUI.cpp . \n \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['&'],
                                                        'type': 'MPoint'},
                                         'returnType': 'MPoint',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                         'isEquivalent': [{'argInfo': {'other': {'doc': 'The other point to compare to. ',
                                                                 'type': 'MPoint'},
                                                       'tol': {'doc': 'The tolerance to use during the comparison.',
                                                               'type': 'double'}},
                                           'args': [('other',
                                                     'MPoint',
                                                     'in'),
                                                    ('tol',
                                                     'double',
                                                     'in')],
                                           'defaults': {'tol': 1e-10},
                                           'deprecated': False,
                                           'doc': '\r\nReturns true if this instance of the point passed as an argument represent the same position within the specified tolerance.',
                                           'inArgs': ['other', 'tol'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'True if the points are equal within the given tolerance and false otherwise. ',
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&'],
                                                              'tol': []},
                                           'types': {'other': 'MPoint',
                                                     'tol': 'double'}}],
                         'rationalize': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nIf this point instance is of the form P(W*x, W*y, W*z, W) (ie. is in homogenous or (for W==1) cartesian form), for some scale factor W != 0, then it is reset to be P(x, y, z, W). This will only work correctly if the point is in homogenous or cartesian form. If the point is already in rational form, the resultsare not defined. \r\n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['&'],
                                                         'type': 'MPoint'},
                                          'returnType': 'MPoint',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
             'pymelEnums': {}},
  'MPointArray': {'enums': {},
                  'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                  ('setLength', 'length')],
                  'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The value of the indicated element. ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MPoint'},
                                               'returnType': 'MPoint',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}},
                                              {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the indicated element ',
                                                              'qualifiers': ['&'],
                                                              'type': 'MPoint'},
                                               'returnType': 'MPoint',
                                               'static': False,
                                               'typeQualifiers': {'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                              'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                  'type': 'MPoint'}},
                                          'args': [('element',
                                                    'MPoint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': ['const',
                                                                         '&']},
                                          'types': {'element': 'MPoint'}},
                                         {'argInfo': {'w': {'doc': 'the value for the w component, defaulted to 1',
                                                            'type': 'double'},
                                                      'x': {'doc': 'the value for the x component ',
                                                            'type': 'double'},
                                                      'y': {'doc': 'the value for the y component ',
                                                            'type': 'double'},
                                                      'z': {'doc': 'the value for the z component, defaulted to 0 ',
                                                            'type': 'double'}},
                                          'args': [('x', 'double', 'in'),
                                                   ('y', 'double', 'in'),
                                                   ('z', 'double', 'in'),
                                                   ('w', 'double', 'in')],
                                          'defaults': {'w': 1.0,
                                                       'z': 0.0},
                                          'deprecated': False,
                                          'doc': '\r\nAdds a new element to the end of the array. The appended element has the indicated values for its x,y,z and w components. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.',
                                          'inArgs': ['x', 'y', 'z', 'w'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'w': [],
                                                             'x': [],
                                                             'y': [],
                                                             'z': []},
                                          'types': {'w': 'double',
                                                    'x': 'double',
                                                    'y': 'double',
                                                    'z': 'double'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'clear': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                               'type': 'MPointArray'}},
                                        'args': [('source',
                                                  'MPointArray',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopy the contents of the source array to this array.',
                                        'inArgs': ['source'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'source': ['const',
                                                                      '&']},
                                        'types': {'source': 'MPointArray'}}],
                              'get': [{'argInfo': {'dest': {'doc': 'the array to populate',
                                                            'type': 'double__array'}},
                                       'args': [('dest',
                                                 'double__array',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the elements of the array into the C++ array of double arrays. No checking is done to ensure that the destination C++ array of double arrays is large enough to hold all the elements of the instance.',
                                       'inArgs': [],
                                       'outArgs': ['dest'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'dest': []},
                                       'types': {'dest': 'double__array'}},
                                      {'argInfo': {'dest': {'doc': 'the array to populate',
                                                            'type': 'float__array'}},
                                       'args': [('dest',
                                                 'float__array',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the elements of the array into the C++ array of float arrays. No checking is done to ensure that the destination C++ array of float arrays is large enough to hold all the elements of the instance.',
                                       'inArgs': [],
                                       'outArgs': ['dest'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'dest': []},
                                       'types': {'dest': 'float__array'}}],
                              'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                  'type': 'MPoint'},
                                                      'index': {'doc': 'the index of the element to set to the the new value',
                                                                'type': 'uint'}},
                                          'args': [('element',
                                                    'MPoint',
                                                    'in'),
                                                   ('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                          'inArgs': ['element', 'index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'element': ['const',
                                                                         '&'],
                                                             'index': ['unsigned']},
                                          'types': {'element': 'MPoint',
                                                    'index': 'uint'}}],
                              'length': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the number of elements in the instance.',
                                          'inArgs': [],
                                          'inverse': ('setLength', False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The number of elements in the instance ',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                'type': 'uint'}},
                                          'args': [('index',
                                                    'uint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                          'inArgs': ['index'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'index': ['unsigned']},
                                          'types': {'index': 'uint'}}],
                              'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                               'type': 'MPoint'},
                                                   'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'}},
                                       'args': [('element',
                                                 'MPoint',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated value.',
                                       'inArgs': ['element', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'element': ['const',
                                                                      '&'],
                                                          'index': ['unsigned']},
                                       'types': {'element': 'MPoint',
                                                 'index': 'uint'}},
                                      {'argInfo': {'index': {'doc': 'the index of the element that is to be set to the the new value ',
                                                             'type': 'uint'},
                                                   'w': {'doc': 'the new value for the w component,defaulted to 1',
                                                         'type': 'double'},
                                                   'x': {'doc': 'the new value for the x component ',
                                                         'type': 'double'},
                                                   'y': {'doc': 'the new value for the y component ',
                                                         'type': 'double'},
                                                   'z': {'doc': 'the new value for the z component,defaulted to 0 ',
                                                         'type': 'double'}},
                                       'args': [('index', 'uint', 'in'),
                                                ('x', 'double', 'in'),
                                                ('y', 'double', 'in'),
                                                ('z', 'double', 'in'),
                                                ('w', 'double', 'in')],
                                       'defaults': {'w': 1.0, 'z': 0.0},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated values. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.',
                                       'inArgs': ['index',
                                                  'x',
                                                  'y',
                                                  'z',
                                                  'w'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'index': ['unsigned'],
                                                          'w': [],
                                                          'x': [],
                                                          'y': [],
                                                          'z': []},
                                       'types': {'index': 'uint',
                                                 'w': 'double',
                                                 'x': 'double',
                                                 'y': 'double',
                                                 'z': 'double'}},
                                      {'argInfo': {'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'},
                                                   'val': {'doc': 'the new value for the indicated element ',
                                                           'type': 'double__array4'}},
                                       'args': [('val',
                                                 'double__array4',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated value. The x component of the element is set to val[0], the y component to val[1], the z component to val[2], and the w component to val[3].',
                                       'inArgs': ['val', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'index': ['unsigned'],
                                                          'val': []},
                                       'types': {'index': 'uint',
                                                 'val': 'double__array4'}},
                                      {'argInfo': {'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                             'type': 'uint'},
                                                   'val': {'doc': 'the new value for the indicated element ',
                                                           'type': 'float__array4'}},
                                       'args': [('val',
                                                 'float__array4',
                                                 'in'),
                                                ('index', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nSets the value of the indicated element to the indicated value. The x component of the element is set to val[0], the y component to val[1], the z component to val[2], and the w component to val[3].',
                                       'inArgs': ['val', 'index'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'index': ['unsigned'],
                                                          'val': []},
                                       'types': {'index': 'uint',
                                                 'val': 'float__array4'}}],
                              'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                    'type': 'uint'}},
                                             'args': [('length',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                             'inArgs': ['length'],
                                             'inverse': ('length', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'length': ['unsigned']},
                                             'types': {'length': 'uint'}}],
                              'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                 'type': 'uint'}},
                                                    'args': [('newIncrement',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                    'inArgs': ['newIncrement'],
                                                    'inverse': ('sizeIncrement',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'newIncrement': ['unsigned']},
                                                    'types': {'newIncrement': 'uint'}}],
                              'sizeIncrement': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                 'inArgs': [],
                                                 'inverse': ('setSizeIncrement',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'length': 'getLength',
                                   'sizeIncrement': 'getSizeIncrement'}},
  'MPointOnMesh': {'enums': {},
                   'methods': {'faceIndex': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method returns the face index data. \r\n  Reprocessed example  \n Examples: \n \n   \n closestPointCmd.cpp . \n \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'getBarycentricCoords': [{'argInfo': {'u': {'doc': 'The relative contribution of the first vertex of the triangle. ',
                                                                           'type': 'float'},
                                                                     'v': {'doc': 'The relative contribution of the second vertex of the triangle. ',
                                                                           'type': 'float'}},
                                                         'args': [('u',
                                                                   'float',
                                                                   'out'),
                                                                  ('v',
                                                                   'float',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nThis method returns the barycentric coordinates of the closest point on the mesh. If the triangle has vertices (a, b, c) then the point returned by  getPoint()  is at coordinates  u*a + v*b + (1 - u - v)*c . The barycentric coordinates are particularly useful when interpolating attributes from one mesh to another.',
                                                         'inArgs': [],
                                                         'outArgs': ['u',
                                                                     'v'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'u': ['&'],
                                                                            'v': ['&']},
                                                         'types': {'u': 'float',
                                                                   'v': 'float'}}],
                               'getNormal': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method returns the normal data. \r\n  Reprocessed example  \n Examples: \n \n   \n closestPointCmd.cpp . \n \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['&'],
                                                             'type': 'MFloatVector'},
                                              'returnType': 'MFloatVector',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'getPoint': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis method returns the point data. \r\n  Reprocessed example  \n Examples: \n \n   \n closestPointCmd.cpp . \n \n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatPoint'},
                                             'returnType': 'MFloatPoint',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                               'triangleIndex': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nThis method returns the triangle index data. \r\n  Reprocessed example  \n Examples: \n \n   \n closestPointCmd.cpp . \n \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                   'pymelEnums': {}},
  'MPolyMessage': {'enums': {'MessageType': {'valueDocs': {'UVSetAdded': 'new UV set added',
                                                           'UVSetDeleted': 'UV set deleted.',
                                                           'currentUVSetChanged': 'current UV set changed',
                                                           'kCurrentUVSetChanged': 'current UV set changed',
                                                           'kUVSetAdded': 'new UV set added',
                                                           'kUVSetDeleted': 'UV set deleted.'},
                                             'values': "Enum('MessageType', {'kUVSetAdded': 0, 'kUVSetDeleted': 1, 'kCurrentUVSetChanged': 2})"}},
                   'methods': {'addPolyComponentIdChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                                 'type': 'void'},
                                                                                  'count': {'doc': 'the size of the array wantIdModifications ',
                                                                                            'type': 'uint'},
                                                                                  'func': {'doc': 'the callback function',
                                                                                           'type': ('MMessage',
                                                                                                    'MComponentFunction')},
                                                                                  'node': {'doc': 'the node callback function should listen to ',
                                                                                           'type': 'MObject'},
                                                                                  'wantIdModifications': {'doc': 'array of booleans specifying what arrays should be provided to the callback function when it is invoked. The entries in this array are kVertexIndex, kEdgeIndex, kFaceIndex for receiving vertex, edge, and face data in the callback respectively. ',
                                                                                                          'type': 'bool__array'}},
                                                                      'args': [('node',
                                                                                'MObject',
                                                                                'in'),
                                                                               ('wantIdModifications',
                                                                                'bool__array',
                                                                                'in'),
                                                                               ('count',
                                                                                'uint',
                                                                                'in'),
                                                                               ('func',
                                                                                ('MMessage',
                                                                                 'MComponentFunction'),
                                                                                'in'),
                                                                               ('clientData',
                                                                                'void',
                                                                                'in')],
                                                                      'defaults': {'clientData': None},
                                                                      'deprecated': False,
                                                                      'doc': '\r\nThis method registers a callback that should be called whenever a poly component id is modified.',
                                                                      'inArgs': ['node',
                                                                                 'wantIdModifications',
                                                                                 'count',
                                                                                 'func',
                                                                                 'clientData'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                     'qualifiers': [],
                                                                                     'type': 'MCallbackId'},
                                                                      'returnType': 'MCallbackId',
                                                                      'static': True,
                                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                         'clientData': ['*'],
                                                                                         'count': ['unsigned'],
                                                                                         'func': [],
                                                                                         'node': ['&'],
                                                                                         'wantIdModifications': []},
                                                                      'types': {'clientData': 'void',
                                                                                'count': 'uint',
                                                                                'func': ('MMessage',
                                                                                         'MComponentFunction'),
                                                                                'node': 'MObject',
                                                                                'wantIdModifications': 'bool__array'}}],
                               'addPolyTopologyChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                              'type': 'void'},
                                                                               'func': {'doc': 'the callback function',
                                                                                        'type': ('MMessage',
                                                                                                 'MNodeFunction')},
                                                                               'node': {'doc': 'the node the callback function should listen to ',
                                                                                        'type': 'MObject'}},
                                                                   'args': [('node',
                                                                             'MObject',
                                                                             'in'),
                                                                            ('func',
                                                                             ('MMessage',
                                                                              'MNodeFunction'),
                                                                             'in'),
                                                                            ('clientData',
                                                                             'void',
                                                                             'in')],
                                                                   'defaults': {'clientData': None},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nThis method registers a callback that will be called when a node impacting the topology of a meshShape is modified. Because the callback is invoked before the mesh has evaluated, the new topology data cannot be queried at the time the callback is received. If you want to receive a callback at a time when the new mesh data can be queried, use the following technique:',
                                                                   'inArgs': ['node',
                                                                              'func',
                                                                              'clientData'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MCallbackId'},
                                                                   'returnType': 'MCallbackId',
                                                                   'static': True,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'clientData': ['*'],
                                                                                      'func': [],
                                                                                      'node': ['&']},
                                                                   'types': {'clientData': 'void',
                                                                             'func': ('MMessage',
                                                                                      'MNodeFunction'),
                                                                             'node': 'MObject'}}],
                               'addUVSetChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                       'type': 'void'},
                                                                        'func': {'doc': 'the callback function ',
                                                                                 'type': ('MPolyMessage',
                                                                                          'MNodeStringTypeFunction')},
                                                                        'node': {'doc': 'the node the callback function should listen to ',
                                                                                 'type': 'MObject'}},
                                                            'args': [('node',
                                                                      'MObject',
                                                                      'in'),
                                                                     ('func',
                                                                      ('MPolyMessage',
                                                                       'MNodeStringTypeFunction'),
                                                                      'in'),
                                                                     ('clientData',
                                                                      'void',
                                                                      'in')],
                                                            'defaults': {'clientData': None},
                                                            'deprecated': False,
                                                            'doc': '\r\nThis method registers a callback that will be called when UV set is modified.',
                                                            'inArgs': ['node',
                                                                       'func',
                                                                       'clientData'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                           'qualifiers': [],
                                                                           'type': 'MCallbackId'},
                                                            'returnType': 'MCallbackId',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'clientData': ['*'],
                                                                               'func': [],
                                                                               'node': ['&']},
                                                            'types': {'clientData': 'void',
                                                                      'func': ('MPolyMessage',
                                                                               'MNodeStringTypeFunction'),
                                                                      'node': 'MObject'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'deletedId': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nThis method returns a constant which is to be used to determine if a component id has been deleted. Compare component ids returned by the callback with the value return by this method. If they are the same then, the component id has been deleted.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Value of a deleted component id. ',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                   'pymelEnums': {'MessageType': "Enum('MessageType', [('UVSetAdded', 0), ('kUVSetAdded', 0), ('UVSetDeleted', 1), ('kUVSetDeleted', 1), ('currentUVSetChanged', 2), ('kCurrentUVSetChanged', 2)], multiKeys=True)"}},
  'MProfiler': {'enums': {},
                'invertibles': [('setBufferSize', 'getBufferSize'),
                                ('setCategoryRecording',
                                 'categoryRecording'),
                                ('setRecordingActive', 'recordingActive')],
                'methods': {'addCategory': [{'argInfo': {'categoryName': {'doc': 'The name of the category to add.',
                                                                          'type': 'char'}},
                                             'args': [('categoryName',
                                                       'char',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nAdd a new profiling category. Categories can only be added when sampling is off and the buffer is empty.  Parameters: \n \n [in]  categoryName  The name of the category to add. \n \n \n Returns: Index of the newly added category or -1 if fail to add the category.  \n',
                                             'inArgs': ['categoryName'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Index of the newly added category or -1 if fail to add the category. ',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': True,
                                             'typeQualifiers': {'categoryName': ['const',
                                                                                 '*']},
                                             'types': {'categoryName': 'char'}}],
                            'categoryRecording': [{'argInfo': {'categoryName': {'doc': 'Name of the category to query.',
                                                                                'type': 'char'}},
                                                   'args': [('categoryName',
                                                             'char',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nDetermine if a given category is allowed to be recorded.',
                                                   'inArgs': ['categoryName'],
                                                   'inverse': ('setCategoryRecording',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if the specified category is currently being recorded, otherwise false. ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {'categoryName': ['const',
                                                                                       '*']},
                                                   'types': {'categoryName': 'char'}},
                                                  {'argInfo': {'categoryId': {'doc': 'Index of the category to query.',
                                                                              'type': 'int'}},
                                                   'args': [('categoryId',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nDetermine if a given category is allowed to be recorded.',
                                                   'inArgs': ['categoryId'],
                                                   'inverse': ('setCategoryRecording',
                                                               False),
                                                   'outArgs': [],
                                                   'pymelName': 'getCategoryRecording',
                                                   'returnInfo': {'doc': 'True if the specified category is currently being recorded, otherwise false. ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {'categoryId': []},
                                                   'types': {'categoryId': 'int'}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'eventBegin': [{'argInfo': {'categoryId': {'doc': 'The index of the category which the event belongs to. ',
                                                                       'type': 'int'},
                                                        'colorIndex': {'doc': 'The color to draw the profiling result in Profiler Window. ',
                                                                       'type': ('MProfiler',
                                                                                'ProfilingColor')},
                                                        'description': {'doc': 'Description of the event.',
                                                                        'type': 'char'},
                                                        'eventName': {'doc': 'The name of the event. ',
                                                                      'type': 'char'}},
                                            'args': [('categoryId',
                                                      'int',
                                                      'in'),
                                                     ('colorIndex',
                                                      ('MProfiler',
                                                       'ProfilingColor'),
                                                      'out'),
                                                     ('eventName',
                                                      'char',
                                                      'in'),
                                                     ('description',
                                                      'char',
                                                      'in')],
                                            'defaults': {'description': None},
                                            'deprecated': False,
                                            'doc': '\nStart a profiling event.',
                                            'inArgs': ['categoryId',
                                                       'eventName',
                                                       'description'],
                                            'outArgs': ['colorIndex'],
                                            'returnInfo': {'doc': 'The index of the started event. ',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': True,
                                            'typeQualifiers': {'categoryId': [],
                                                               'colorIndex': [],
                                                               'description': ['const',
                                                                               '*'],
                                                               'eventName': ['const',
                                                                             '*']},
                                            'types': {'categoryId': 'int',
                                                      'colorIndex': ('MProfiler',
                                                                     'ProfilingColor'),
                                                      'description': 'char',
                                                      'eventName': 'char'}}],
                            'eventDataAvailable': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nDetermine if any recorded event data is available.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                            'eventEnd': [{'argInfo': {'eventId': {'doc': 'The index of the event to stop. ',
                                                                  'type': 'int'}},
                                          'args': [('eventId',
                                                    'int',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nStop a profiling event.',
                                          'inArgs': ['eventId'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'eventId': []},
                                          'types': {'eventId': 'int'}}],
                            'getAllCategories': [{'argInfo': {'categoryNames': {'doc': 'The names of all the existing categories. ',
                                                                                'type': 'MStringArray'}},
                                                  'args': [('categoryNames',
                                                            'MStringArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturn an array of the existing category names.',
                                                  'inArgs': [],
                                                  'outArgs': ['categoryNames'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': True,
                                                  'typeQualifiers': {'categoryNames': ['&']},
                                                  'types': {'categoryNames': 'MStringArray'}}],
                            'getBufferSize': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns the profiling buffer size.',
                                               'inArgs': [],
                                               'inverse': ('setBufferSize',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                            'getCPUId': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                     'type': 'int'}},
                                          'args': [('eventIndex',
                                                    'int',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns the CPU id the event ran on.',
                                          'inArgs': ['eventIndex'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The CPU id the event ran on. ',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': True,
                                          'typeQualifiers': {'eventIndex': []},
                                          'types': {'eventIndex': 'int'}}],
                            'getCategoryIndex': [{'argInfo': {'categoryName': {'doc': 'Name of the category to query.',
                                                                               'type': 'char'}},
                                                  'args': [('categoryName',
                                                            'char',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the category index.',
                                                  'inArgs': ['categoryName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The index of the specified category. -1 if no category with this name. ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': True,
                                                  'typeQualifiers': {'categoryName': ['const',
                                                                                      '*']},
                                                  'types': {'categoryName': 'char'}}],
                            'getCategoryName': [{'argInfo': {'categoryId': {'doc': 'Index of the category to query.',
                                                                            'type': 'int'}},
                                                 'args': [('categoryId',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the category name.',
                                                 'inArgs': ['categoryId'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The name of the specified category. ',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {'categoryId': []},
                                                 'types': {'categoryId': 'int'}}],
                            'getColor': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                     'type': 'int'}},
                                          'args': [('eventIndex',
                                                    'int',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns the color used to draw this event in the Profiler Window.',
                                          'inArgs': ['eventIndex'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The color used to draw this event in the Profiler Window. ',
                                                         'qualifiers': [],
                                                         'type': ('MProfiler',
                                                                  'ProfilingColor')},
                                          'returnType': ('MProfiler',
                                                         'ProfilingColor'),
                                          'static': True,
                                          'typeQualifiers': {'eventIndex': []},
                                          'types': {'eventIndex': 'int'}}],
                            'getDescription': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                           'type': 'int'}},
                                                'args': [('eventIndex',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the event description.',
                                                'inArgs': ['eventIndex'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The event description. ',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {'eventIndex': []},
                                                'types': {'eventIndex': 'int'}}],
                            'getEventCategory': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                             'type': 'int'}},
                                                  'args': [('eventIndex',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the category the event belongs to.',
                                                  'inArgs': ['eventIndex'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The category the event belongs to. ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': True,
                                                  'typeQualifiers': {'eventIndex': []},
                                                  'types': {'eventIndex': 'int'}}],
                            'getEventCount': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns the events count.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                            'getEventDuration': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                             'type': 'int'}},
                                                  'args': [('eventIndex',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the duration of the event in microseconds. Note that a signal event has a 0 duration. If you need to convert this time to other time unit, please create a  MTime (microseconds/1000, kMilliSeconds) then do all time conversions by  MTime .',
                                                  'inArgs': ['eventIndex'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The duration of the event in microseconds. ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': True,
                                                  'typeQualifiers': {'eventIndex': []},
                                                  'types': {'eventIndex': 'int'}}],
                            'getEventName': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                         'type': 'int'}},
                                              'args': [('eventIndex',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the name of the specified event.',
                                              'inArgs': ['eventIndex'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of the specified event. ',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {'eventIndex': []},
                                              'types': {'eventIndex': 'int'}}],
                            'getEventTime': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                         'type': 'int'}},
                                              'args': [('eventIndex',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the time the event happens in microseconds. If you need to convert this time to other time unit, please create a  MTime (microseconds/1000, kMilliSeconds) then do all time conversions by  MTime .',
                                              'inArgs': ['eventIndex'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The time the event happens in microseconds. ',
                                                             'qualifiers': [],
                                                             'type': 'MUint64'},
                                              'returnType': 'MUint64',
                                              'static': True,
                                              'typeQualifiers': {'eventIndex': []},
                                              'types': {'eventIndex': 'int'}}],
                            'getNumberOfCPUs': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturn the number of CPUS used for profiling.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                            'getThreadDuration': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                              'type': 'int'}},
                                                   'args': [('eventIndex',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the duration of the thread for a given event in microseconds.',
                                                   'inArgs': ['eventIndex'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The duration of the thread in microseconds. ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': True,
                                                   'typeQualifiers': {'eventIndex': []},
                                                   'types': {'eventIndex': 'int'}}],
                            'getThreadId': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                        'type': 'int'}},
                                             'args': [('eventIndex',
                                                       'int',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the thread id the event ran on.',
                                             'inArgs': ['eventIndex'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The thread id the event ran on. ',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': True,
                                             'typeQualifiers': {'eventIndex': []},
                                             'types': {'eventIndex': 'int'}}],
                            'isDataFromFile': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturn if the current event data was loaded from file.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                            'isSignalEvent': [{'argInfo': {'eventIndex': {'doc': 'The index of the event in the profiling buffer.',
                                                                          'type': 'int'}},
                                               'args': [('eventIndex',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nDetermine if a given event is a Signal Event.',
                                               'inArgs': ['eventIndex'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'True if the event is a Single Event, false otherwise. ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {'eventIndex': []},
                                               'types': {'eventIndex': 'int'}}],
                            'loadRecording': [{'argInfo': {'fileName': {'doc': 'File location to load from.',
                                                                        'type': 'MString'}},
                                               'args': [('fileName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nLoad a recording from a specified file location',
                                               'inArgs': ['fileName'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'True if recording was loaded. ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {'fileName': ['const',
                                                                               '&']},
                                               'types': {'fileName': 'MString'}}],
                            'recordingActive': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nDetermine if recording is active.',
                                                 'inArgs': [],
                                                 'inverse': ('setRecordingActive',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                            'removeCategory': [{'argInfo': {'categoryName': {'doc': 'The name of the category to remove.',
                                                                             'type': 'char'}},
                                                'args': [('categoryName',
                                                          'char',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRemove an existing profiling category. User can only remove category when the sampling is off and the buffer is empty.  Parameters: \n \n [in]  categoryName  The name of the category to remove. \n \n \n Returns: Index of the removed category or -1 if fail to remove the category..  \n',
                                                'inArgs': ['categoryName'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Index of the removed category or -1 if fail to remove the category.. ',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': True,
                                                'typeQualifiers': {'categoryName': ['const',
                                                                                    '*']},
                                                'types': {'categoryName': 'char'}}],
                            'resetRecording': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nClear out any recorded data. If a recording is active (samplingActive() returns True) then the data will not be cleared.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                            'saveRecording': [{'argInfo': {'fileName': {'doc': 'File location to save to.',
                                                                        'type': 'MString'}},
                                               'args': [('fileName',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nSave recording to a specified file location',
                                               'inArgs': ['fileName'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'True if recording was saved. ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {'fileName': ['const',
                                                                               '&']},
                                               'types': {'fileName': 'MString'}}],
                            'setBufferSize': [{'argInfo': {'sizeInMegaytes': {'doc': 'The new profiling buffer size in megabytes.',
                                                                              'type': 'int'}},
                                               'args': [('sizeInMegaytes',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "\nSet the new profiling buffer size. The new buffer size will take effect for next recording. Before next recording started, the events already in the buffer won't be affected.",
                                               'inArgs': ['sizeInMegaytes'],
                                               'inverse': ('getBufferSize',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'sizeInMegaytes': []},
                                               'types': {'sizeInMegaytes': 'int'}}],
                            'setCategoryRecording': [{'argInfo': {'active': {'doc': 'If True, the category will be recorded when profiling starts. If False, the category will not be recorded when profiling starts. ',
                                                                             'type': 'bool'},
                                                                  'categoryName': {'doc': 'Name of the category to set. ',
                                                                                   'type': 'char'}},
                                                      'args': [('categoryName',
                                                                'char',
                                                                'in'),
                                                               ('active',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nEnable or disable the recording of the given category.',
                                                      'inArgs': ['categoryName',
                                                                 'active'],
                                                      'inverse': ('categoryRecording',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'active': [],
                                                                         'categoryName': ['const',
                                                                                          '*']},
                                                      'types': {'active': 'bool',
                                                                'categoryName': 'char'}},
                                                     {'argInfo': {'active': {'doc': 'If True, the category will be recorded when profiling starts. If False, the category will not be recorded when profiling starts. ',
                                                                             'type': 'bool'},
                                                                  'categoryId': {'doc': 'The category to set. ',
                                                                                 'type': 'int'}},
                                                      'args': [('categoryId',
                                                                'int',
                                                                'in'),
                                                               ('active',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nEnable or disable the recording of the given category.',
                                                      'inArgs': ['categoryId',
                                                                 'active'],
                                                      'inverse': ('categoryRecording',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'active': [],
                                                                         'categoryId': []},
                                                      'types': {'active': 'bool',
                                                                'categoryId': 'int'}}],
                            'setRecordingActive': [{'argInfo': {'val': {'doc': 'Value for enabling ',
                                                                        'type': 'bool'}},
                                                    'args': [('val',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nEnable or disable recording',
                                                    'inArgs': ['val'],
                                                    'inverse': ('recordingActive',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'val': []},
                                                    'types': {'val': 'bool'}}],
                            'signalEvent': [{'argInfo': {'categoryId': {'doc': 'The index of the category which the event belongs to. ',
                                                                        'type': 'int'},
                                                         'colorIndex': {'doc': 'The color to draw the profiling result in Profiler Window. ',
                                                                        'type': ('MProfiler',
                                                                                 'ProfilingColor')},
                                                         'description': {'doc': 'Description of the event. ',
                                                                         'type': 'char'},
                                                         'eventName': {'doc': 'The name of the event. ',
                                                                       'type': 'char'}},
                                             'args': [('categoryId',
                                                       'int',
                                                       'in'),
                                                      ('colorIndex',
                                                       ('MProfiler',
                                                        'ProfilingColor'),
                                                       'out'),
                                                      ('eventName',
                                                       'char',
                                                       'in'),
                                                      ('description',
                                                       'char',
                                                       'in')],
                                             'defaults': {'description': None},
                                             'deprecated': False,
                                             'doc': '\nSending out a profiling signal.',
                                             'inArgs': ['categoryId',
                                                        'eventName',
                                                        'description'],
                                             'outArgs': ['colorIndex'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'categoryId': [],
                                                                'colorIndex': [],
                                                                'description': ['const',
                                                                                '*'],
                                                                'eventName': ['const',
                                                                              '*']},
                                             'types': {'categoryId': 'int',
                                                       'colorIndex': ('MProfiler',
                                                                      'ProfilingColor'),
                                                       'description': 'char',
                                                       'eventName': 'char'}}]},
                'pymelEnums': {},
                'pymelMethods': {'categoryRecording': 'getCategoryRecording',
                                 'recordingActive': 'getRecordingActive'}},
  'MProfilingScope': {'enums': {},
                      'methods': {'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                      'pymelEnums': {}},
  'MProgressWindow': {'enums': {},
                      'invertibles': [('setInterruptable',
                                       'isInterruptable'),
                                      ('setProgressMax', 'progressMax'),
                                      ('setTitle', 'title'),
                                      ('setProgressStatus',
                                       'progressStatus'),
                                      ('setProgressMin', 'progressMin'),
                                      ('setProgress', 'progress')],
                      'methods': {'advanceProgress': [{'argInfo': {'amount': {'doc': 'Value to add to current progress',
                                                                              'type': 'int'}},
                                                       'args': [('amount',
                                                                 'int',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nIncreases the progress value by amount. If the resulting progress value is not between  progressMin()  and  progressMax()  inclusively, it is set to whichever of  progressMin()  or  progressMax()  is closest.',
                                                       'inArgs': ['amount'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': True,
                                                       'typeQualifiers': {'amount': ['const']},
                                                       'types': {'amount': 'int'}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'endProgress': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDestroys the progress window and removes it from the screen. This method also unreserves the progress window, making it available for future reservation.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                  'isCancelled': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDetermine whether the user has tried to cancel an interruptable progress window.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'true when user has tried to cancel progress. If the progress window is not interruptable, this method returns false. ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                  'isInterruptable': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nDetermine whether the progress window is interruptable.',
                                                       'inArgs': [],
                                                       'inverse': ('setInterruptable',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'true when the progress window is interruptable ',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*']},
                                                       'types': {}}],
                                  'progress': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nGet the progress value.',
                                                'inArgs': [],
                                                'inverse': ('setProgress',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Progress value. Returns -1 if query fails. ',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': True,
                                                'typeQualifiers': {'ReturnStatus': ['*']},
                                                'types': {}}],
                                  'progressMax': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the maximum progress value.',
                                                   'inArgs': [],
                                                   'inverse': ('setProgressMax',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Maximum progress value. Returns -1 if query fails. ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                  'progressMin': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the minimum progress value.',
                                                   'inArgs': [],
                                                   'inverse': ('setProgressMin',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Minimum progress value. Returns -1 if query fails. ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': True,
                                                   'typeQualifiers': {'ReturnStatus': ['*']},
                                                   'types': {}}],
                                  'progressStatus': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the progress status string.',
                                                      'inArgs': [],
                                                      'inverse': ('setProgressStatus',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Progress status string. ',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*']},
                                                      'types': {}}],
                                  'reserve': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReserves a progress window for use through this class. This method must be called before setting progress window parameters or starting progress.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'true if the progress window was successfully reserved ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                  'setInterruptable': [{'argInfo': {'value': {'doc': 'True if the progress window should be made interruptable.',
                                                                              'type': 'bool'}},
                                                        'args': [('value',
                                                                  'bool',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets whether the progress window is interruptable. An interruptable progress window can accept a signal from the user indicating that the operation should be cancelled.',
                                                        'inArgs': ['value'],
                                                        'inverse': ('isInterruptable',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'value': ['const']},
                                                        'types': {'value': 'bool'}}],
                                  'setProgress': [{'argInfo': {'progress': {'doc': 'New progress value',
                                                                            'type': 'int'}},
                                                   'args': [('progress',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the progress value. If progress is not between  progressMin()  and  progressMax()  inclusively, it is set to whichever of  progressMin()  or  progressMax()  is closest.',
                                                   'inArgs': ['progress'],
                                                   'inverse': ('progress',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'progress': ['const']},
                                                   'types': {'progress': 'int'}}],
                                  'setProgressMax': [{'argInfo': {'maxValue': {'doc': 'Maximum progress value',
                                                                               'type': 'int'}},
                                                      'args': [('maxValue',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the maximum value for the progress. Any progress value greater then maxValue will be set to maxValue, with the progress bar displayed as full.',
                                                      'inArgs': ['maxValue'],
                                                      'inverse': ('progressMax',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'maxValue': ['const']},
                                                      'types': {'maxValue': 'int'}}],
                                  'setProgressMin': [{'argInfo': {'minValue': {'doc': 'Minimum progress value',
                                                                               'type': 'int'}},
                                                      'args': [('minValue',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the minimum value for the progress. Any progress value less then minValue will be set to minValue, with the progress bar displayed as empty.',
                                                      'inArgs': ['minValue'],
                                                      'inverse': ('progressMin',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'minValue': ['const']},
                                                      'types': {'minValue': 'int'}}],
                                  'setProgressRange': [{'argInfo': {'maxValue': {'doc': 'Maximum progress value',
                                                                                 'type': 'int'},
                                                                    'minValue': {'doc': 'Minimum progress value ',
                                                                                 'type': 'int'}},
                                                        'args': [('minValue',
                                                                  'int',
                                                                  'in'),
                                                                 ('maxValue',
                                                                  'int',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSets the range (minValue, maxValue) of the progress indicator. When the progress value is set through  setProgress()  or  advanceProgress() , it is checked against the minimum and maximum progress values. If the new progress value lies outside this range, it is clamped to a value in this range.',
                                                        'inArgs': ['minValue',
                                                                   'maxValue'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'maxValue': ['const'],
                                                                           'minValue': ['const']},
                                                        'types': {'maxValue': 'int',
                                                                  'minValue': 'int'}}],
                                  'setProgressStatus': [{'argInfo': {'progressStatus': {'doc': 'New status string',
                                                                                        'type': 'MString'}},
                                                         'args': [('progressStatus',
                                                                   'MString',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the progress status string. This string is shown above the progress bar and usually is of the form "Performing operation:  XXX " where  XXX  is a numerical indication of the amount completed.',
                                                         'inArgs': ['progressStatus'],
                                                         'inverse': ('progressStatus',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': True,
                                                         'typeQualifiers': {'progressStatus': ['const',
                                                                                               '&']},
                                                         'types': {'progressStatus': 'MString'}}],
                                  'setTitle': [{'argInfo': {'title': {'doc': 'New title',
                                                                      'type': 'MString'}},
                                                'args': [('title',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the title of the progress window.',
                                                'inArgs': ['title'],
                                                'inverse': ('title',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'title': ['const',
                                                                             '&']},
                                                'types': {'title': 'MString'}}],
                                  'startProgress': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nDisplays the progress window on the screen.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                  'title': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nGet the window title.',
                                             'inArgs': [],
                                             'inverse': ('setTitle',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Window title string. ',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': True,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'progress': 'getProgress',
                                       'progressMax': 'getProgressMax',
                                       'progressMin': 'getProgressMin',
                                       'progressStatus': 'getProgressStatus',
                                       'title': 'getTitle'}},
  'MQtUtil': {'enums': {},
              'methods': {'addWidgetToMayaLayout': [{'argInfo': {'control': {'doc': 'The QWidget to be added. If the control is named (with QObject::setObjectName), the name may be modified to make it unique, this will be done by adding a numeric suffix. Otherwise a default name, based on the class name will be used. ',
                                                                             'type': ('MQtUtil',
                                                                                      'QWidget')},
                                                                 'layout': {'doc': 'The placeholder widget for the Maya layout ',
                                                                            'type': ('MQtUtil',
                                                                                     'QWidget')},
                                                                 'uiType': {'doc': 'A Maya ui-type name for the QWidget being added. Defaults to the name of its class. This name can be used by the Maya commands lsUI and objectTypeUI.',
                                                                            'type': 'MString'}},
                                                     'args': [('control',
                                                               ('MQtUtil',
                                                                'QWidget'),
                                                               'in'),
                                                              ('layout',
                                                               ('MQtUtil',
                                                                'QWidget'),
                                                               'in'),
                                                              ('uiType',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {'uiType': 'MString()'},
                                                     'deprecated': False,
                                                     'doc': '\nAdds a QWidget to an existing Maya layout, such as that returned by  getCurrentParent()  or getLayout().',
                                                     'inArgs': ['control',
                                                                'layout',
                                                                'uiType'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'String containing the full hierarchical name of the added control, or an empty string on failure. Commands which create custom Maya controls must return this name so that it can be used in scripts to find the added control. ',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': True,
                                                     'typeQualifiers': {'control': ['*'],
                                                                        'layout': ['*'],
                                                                        'uiType': ['const',
                                                                                   '&']},
                                                     'types': {'control': ('MQtUtil',
                                                                           'QWidget'),
                                                               'layout': ('MQtUtil',
                                                                          'QWidget'),
                                                               'uiType': 'MString'}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'createCursor': [{'argInfo': {'autoScale': {'doc': 'A boolean that if true, looks for a version of the cursor at the current scaling factor.',
                                                                      'type': 'bool'},
                                                        'cursorName': {'doc': 'The cursor to look up.',
                                                                       'type': 'MString'}},
                                            'args': [('cursorName',
                                                      'MString',
                                                      'in'),
                                                     ('autoScale',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'autoScale': True},
                                            'deprecated': False,
                                            'doc': '\nLooks for a cursor first in the Qt resources, and then in a file on disk. Returns the cursor with the given name. If autoscale is true, then the cursor at the appropriate DPI is selected.',
                                            'inArgs': ['cursorName',
                                                       'autoScale'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Pointer to the created cursor. ',
                                                           'qualifiers': ['*'],
                                                           'type': ('MQtUtil',
                                                                    'QCursor')},
                                            'returnType': ('MQtUtil',
                                                           'QCursor'),
                                            'static': True,
                                            'typeQualifiers': {'autoScale': [],
                                                               'cursorName': ['const',
                                                                              '&']},
                                            'types': {'autoScale': 'bool',
                                                      'cursorName': 'MString'}}],
                          'createIcon': [{'argInfo': {'autoScale': {'doc': 'A boolean that if true, looks for a version of the icon at the current scaling factor.',
                                                                    'type': 'bool'},
                                                      'iconName': {'doc': 'The image to look up.',
                                                                   'type': 'MString'}},
                                          'args': [('iconName',
                                                    'MString',
                                                    'in'),
                                                   ('autoScale',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'autoScale': True},
                                          'deprecated': False,
                                          'doc': '\nLooks for a icon first in the Qt resources, and then in a file on disk. Returns the icon with the given name. If autoscale is true, then the icon at the appropriate DPI is selected.',
                                          'inArgs': ['iconName',
                                                     'autoScale'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Pointer to the created icon. ',
                                                         'qualifiers': ['*'],
                                                         'type': ('MQtUtil',
                                                                  'QIcon')},
                                          'returnType': ('MQtUtil',
                                                         'QIcon'),
                                          'static': True,
                                          'typeQualifiers': {'autoScale': [],
                                                             'iconName': ['const',
                                                                          '&']},
                                          'types': {'autoScale': 'bool',
                                                    'iconName': 'MString'}}],
                          'createPixmap': [{'argInfo': {'autoScale': {'doc': 'A boolean that if true, looks for a version of the image at the current scaling factor.',
                                                                      'type': 'bool'},
                                                        'imageName': {'doc': 'The image to look up.',
                                                                      'type': 'MString'}},
                                            'args': [('imageName',
                                                      'MString',
                                                      'in'),
                                                     ('autoScale',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'autoScale': True},
                                            'deprecated': False,
                                            'doc': '\nLooks for a pixmap first in the Qt resources, and then in a file on disk. Returns the pixmap with the given name. If autoscale is true, then the image at the appropriate DPI is selected.',
                                            'inArgs': ['imageName',
                                                       'autoScale'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Pointer to the created pixmap. ',
                                                           'qualifiers': ['*'],
                                                           'type': ('MQtUtil',
                                                                    'QPixmap')},
                                            'returnType': ('MQtUtil',
                                                           'QPixmap'),
                                            'static': True,
                                            'typeQualifiers': {'autoScale': [],
                                                               'imageName': ['const',
                                                                             '&']},
                                            'types': {'autoScale': 'bool',
                                                      'imageName': 'MString'}}],
                          'deregisterUIType': [{'argInfo': {'className': {'doc': 'The name of the class to be de-registered.',
                                                                          'type': 'MString'}},
                                                'args': [('className',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nDe-registers a widget class (UI-type) which has been previously registered with  registerUIType() .',
                                                'inArgs': ['className'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'true if successful, false if the class name is not registered. ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'className': ['const',
                                                                                 '&']},
                                                'types': {'className': 'MString'}}],
                          'dpiScale': [{'argInfo': {'size': {'doc': 'The size in Maya UI',
                                                             'type': 'int'}},
                                        'args': [('size', 'int', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nGet the scaled size for Maya interface scaling. This public method should be used when define the size of Qt widget, e.g.: Setting the width of a Maya Qt control.',
                                        'inArgs': ['size'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The scaled size in Qt. ',
                                                       'qualifiers': [],
                                                       'type': 'int'},
                                        'returnType': 'int',
                                        'static': True,
                                        'typeQualifiers': {'size': []},
                                        'types': {'size': 'int'}},
                                       {'argInfo': {'size': {'doc': 'The size in Maya UI',
                                                             'type': 'float'}},
                                        'args': [('size', 'float', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nGet the scaled size for Maya interface scaling. This public method should be used when define the size of Qt widget, e.g.: Setting the width of a Maya Qt control.',
                                        'inArgs': ['size'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The scaled size in Qt. ',
                                                       'qualifiers': [],
                                                       'type': 'float'},
                                        'returnType': 'float',
                                        'static': True,
                                        'typeQualifiers': {'size': []},
                                        'types': {'size': 'float'}}],
                          'findControl': [{'argInfo': {'ancestor': {'doc': 'Pointer to an ancestor UI element which appears somewhere in the UI hierarchy above the control. If not NULL then the search will begin at the specified ancestor and descend from there.',
                                                                    'type': ('MQtUtil',
                                                                             'QWidget')},
                                                       'controlName': {'doc': 'Name of the control within Maya. May be a plain name ("myButton") or a hierarchical name ("myWin|myLayout|myButton"). If a hierarchical name is supplied then the search will begin with the UI element at the start of the hierarchy and descend from there.',
                                                                       'type': 'MString'}},
                                           'args': [('controlName',
                                                     'MString',
                                                     'in'),
                                                    ('ancestor',
                                                     ('MQtUtil',
                                                      'QWidget'),
                                                     'in')],
                                           'defaults': {'ancestor': None},
                                           'deprecated': False,
                                           'doc': '\nReturns the QWidget for the named Maya control.',
                                           'inArgs': ['controlName',
                                                      'ancestor'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': "Pointer to the control's underlying QWidget. Returns NULL if the control is not found. ",
                                                          'qualifiers': ['*'],
                                                          'type': ('MQtUtil',
                                                                   'QWidget')},
                                           'returnType': ('MQtUtil',
                                                          'QWidget'),
                                           'static': True,
                                           'typeQualifiers': {'ancestor': ['const',
                                                                           '*'],
                                                              'controlName': []},
                                           'types': {'ancestor': ('MQtUtil',
                                                                  'QWidget'),
                                                     'controlName': 'MString'}}],
                          'findLayout': [{'argInfo': {'ancestor': {'doc': 'Pointer to an ancestor UI element which appears somewhere in the UI hierarchy above the layout. If not NULL then the search will begin at the specified ancestor and descend from there.',
                                                                   'type': ('MQtUtil',
                                                                            'QWidget')},
                                                      'layoutName': {'doc': 'Name of the layout within Maya. May be a plain name ("myLayout") or a hierarchical name ("myWin|myLayout"). If a hierarchical name is supplied then the search will begin with the UI element at the start of the hierarchy and then descend from there.',
                                                                     'type': 'MString'}},
                                          'args': [('layoutName',
                                                    'MString',
                                                    'in'),
                                                   ('ancestor',
                                                    ('MQtUtil',
                                                     'QWidget'),
                                                    'in')],
                                          'defaults': {'ancestor': None},
                                          'deprecated': False,
                                          'doc': '\nReturns the QWidget for the named Maya layout.',
                                          'inArgs': ['layoutName',
                                                     'ancestor'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "Pointer to the layout's underlying QWidget. Returns NULL if the layout is not found. ",
                                                         'qualifiers': ['*'],
                                                         'type': ('MQtUtil',
                                                                  'QWidget')},
                                          'returnType': ('MQtUtil',
                                                         'QWidget'),
                                          'static': True,
                                          'typeQualifiers': {'ancestor': ['const',
                                                                          '*'],
                                                             'layoutName': []},
                                          'types': {'ancestor': ('MQtUtil',
                                                                 'QWidget'),
                                                    'layoutName': 'MString'}}],
                          'findMenuItem': [{'argInfo': {'itemName': {'doc': 'Name of the menuItem within Maya. May be a plain name ("myItem") or a hierarchical name ("myMenu|myItem"). If a hierarchical name is supplied then the search will begin with the UI element at the start of the hierarchy and then descend from there.',
                                                                     'type': 'MString'}},
                                            'args': [('itemName',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns the QAction for the named Maya menuItem.',
                                            'inArgs': ['itemName'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "Pointer to the menuItem's underlying QAction. Returns NULL if the menuItem is not found. ",
                                                           'qualifiers': ['*'],
                                                           'type': ('MQtUtil',
                                                                    'QAction')},
                                            'returnType': ('MQtUtil',
                                                           'QAction'),
                                            'static': True,
                                            'typeQualifiers': {'itemName': []},
                                            'types': {'itemName': 'MString'}}],
                          'findWindow': [{'argInfo': {'windowName': {'doc': 'Name of the window within Maya.',
                                                                     'type': 'MString'}},
                                          'args': [('windowName',
                                                    'MString',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturns the QWidget for the named Maya window.',
                                          'inArgs': ['windowName'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': "Pointer to the window's underlying QWidget. Returns NULL if the window is not found. ",
                                                         'qualifiers': ['*'],
                                                         'type': ('MQtUtil',
                                                                  'QWidget')},
                                          'returnType': ('MQtUtil',
                                                         'QWidget'),
                                          'static': True,
                                          'typeQualifiers': {'windowName': []},
                                          'types': {'windowName': 'MString'}}],
                          'fullName': [{'argInfo': {'uiElement': {'doc': "pointer to a UI element's QObject",
                                                                  'type': ('MQtUtil',
                                                                           'QObject')}},
                                        'args': [('uiElement',
                                                  ('MQtUtil',
                                                   'QObject'),
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "\nReturns the full, hierarchical name of a UI element. This is the name which uniquely identifies the element within Maya and can be passed to Maya's UI commands.",
                                        'inArgs': ['uiElement'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'String containing the full hierarchical name of the UI element, or an empty string if the element does not exist. ',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': True,
                                        'typeQualifiers': {'uiElement': ['const',
                                                                         '*']},
                                        'types': {'uiElement': ('MQtUtil',
                                                                'QObject')}}],
                          'getCurrentParent': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the placeholder widget for the current layout if there is one.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': ('MQtUtil',
                                                                        'QWidget')},
                                                'returnType': ('MQtUtil',
                                                               'QWidget'),
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                          'getLayoutChildren': [{'argInfo': {'layout': {'doc': "Pointer to a Maya layout's QWidget. See findLayout() for a description of the relationship between Maya layouts and QWidgets.",
                                                                        'type': ('MQtUtil',
                                                                                 'QWidget')}},
                                                 'args': [('layout',
                                                           ('MQtUtil',
                                                            'QWidget'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns a list of all the Maya UI elements parented directly beneath the specified Maya layout.',
                                                 'inArgs': ['layout'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A list of QObjects for all of the Maya controls and layouts parented beneath the specified layout. ',
                                                                'qualifiers': ['QObject',
                                                                               '*',
                                                                               '>'],
                                                                'type': ('MQtUtil',
                                                                         'QList<')},
                                                 'returnType': ('MQtUtil',
                                                                'QList<'),
                                                 'static': True,
                                                 'typeQualifiers': {'layout': ['const',
                                                                               '*']},
                                                 'types': {'layout': ('MQtUtil',
                                                                      'QWidget')}}],
                          'getParent': [{'argInfo': {'uiElement': {'doc': "A pointer to a UI element's QObject",
                                                                   'type': ('MQtUtil',
                                                                            'QObject')}},
                                         'args': [('uiElement',
                                                   ('MQtUtil',
                                                    'QObject'),
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': "\nReturns a pointer to a UI element's parent element within Maya's UI hierarchy.",
                                         'inArgs': ['uiElement'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': "A pointer to the element's parent element, or NULL is the element has no parent or is a window. ",
                                                        'qualifiers': ['*'],
                                                        'type': ('MQtUtil',
                                                                 'QObject')},
                                         'returnType': ('MQtUtil',
                                                        'QObject'),
                                         'static': True,
                                         'typeQualifiers': {'uiElement': ['const',
                                                                          '*']},
                                         'types': {'uiElement': ('MQtUtil',
                                                                 'QObject')}}],
                          'mainWindow': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\nReturns Maya's main window.",
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['*'],
                                                         'type': ('MQtUtil',
                                                                  'QWidget')},
                                          'returnType': ('MQtUtil',
                                                         'QWidget'),
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'nativeWindow': [{'argInfo': {'control': {'doc': 'Control whose native window handle is to be returned.',
                                                                    'type': ('MQtUtil',
                                                                             'QWidget')}},
                                            'args': [('control',
                                                      ('MQtUtil',
                                                       'QWidget'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\n/*! Returns a platform-specific native window handle for the specified control.',
                                            'inArgs': ['control'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': "The native window handle of the specified control. On Linux this will be an Xlib 'Window'. On 32-bit OS X it will be an 'HIViewRef'. On 64-bit OS X it will be an 'NSView' pointer. On Microsoft Windows it will be an 'HWND'. ",
                                                           'qualifiers': [],
                                                           'type': ('MQtUtil',
                                                                    'MNativeWindowHdl')},
                                            'returnType': ('MQtUtil',
                                                           'MNativeWindowHdl'),
                                            'static': True,
                                            'typeQualifiers': {'control': ['const',
                                                                           '*']},
                                            'types': {'control': ('MQtUtil',
                                                                  'QWidget')}}],
                          'registerUIType': [{'argInfo': {'className': {'doc': 'The name of the QWidget-derived class created by the function. ',
                                                                        'type': 'MString'},
                                                          'command': {'doc': 'The command to be used to edit the created QWidget.',
                                                                      'type': 'MString'},
                                                          'fn': {'doc': 'The creator function. ',
                                                                 'type': ('MQtUtil',
                                                                          'UITypeCreatorFn')}},
                                              'args': [('className',
                                                        'MString',
                                                        'in'),
                                                       ('fn',
                                                        ('MQtUtil',
                                                         'UITypeCreatorFn'),
                                                        'in'),
                                                       ('command',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nRegisters a class name (UI-type) with a function to create the QWidget of that type, and a command to edit it with.',
                                              'inArgs': ['className',
                                                         'fn',
                                                         'command'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'true if successful, false if the class name is already registered. ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': True,
                                              'typeQualifiers': {'className': ['const',
                                                                               '&'],
                                                                 'command': ['const',
                                                                             '&'],
                                                                 'fn': []},
                                              'types': {'className': 'MString',
                                                        'command': 'MString',
                                                        'fn': ('MQtUtil',
                                                               'UITypeCreatorFn')}}],
                          'resourceGLContext': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns Maya internal QGLContext that the plug-in may use to create resource-sharing OpenGL context.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': ('MQtUtil',
                                                                         'QGLContext')},
                                                 'returnType': ('MQtUtil',
                                                                'QGLContext'),
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                          'toMString': [{'argInfo': {'qstr': {'doc': 'QString to be converted.',
                                                              'type': ('MQtUtil',
                                                                       'QString')}},
                                         'args': [('qstr',
                                                   ('MQtUtil',
                                                    'QString'),
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nConvenience utility to convert a QString to an  MString .',
                                         'inArgs': ['qstr'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': "An MString containing the same text as 'qstr'. ",
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': True,
                                         'typeQualifiers': {'qstr': ['const',
                                                                     '&']},
                                         'types': {'qstr': ('MQtUtil',
                                                            'QString')}}],
                          'toQString': [{'argInfo': {'mstr': {'doc': 'MString to be converted.',
                                                              'type': 'MString'}},
                                         'args': [('mstr',
                                                   'MString',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nConvenience utility to convert an  MString  to a QString.',
                                         'inArgs': ['mstr'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': "A QString containing the same text as 'mstr'. ",
                                                        'qualifiers': [],
                                                        'type': ('MQtUtil',
                                                                 'QString')},
                                         'returnType': ('MQtUtil',
                                                        'QString'),
                                         'static': True,
                                         'typeQualifiers': {'mstr': ['const',
                                                                     '&']},
                                         'types': {'mstr': 'MString'}}]},
              'pymelEnums': {}},
  'MQuaternion': {'enums': {},
                  'invertibles': [('setAxisAngle', 'getAxisAngle')],
                  'methods': {'MMatrix': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': ('MQuaternion',
                                                                   'operator')},
                                           'returnType': ('MQuaternion',
                                                          'operator'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              '__add__': [{'argInfo': {'other': {'doc': 'the quaternion to be added to this quaternion',
                                                                 'type': 'MQuaternion'}},
                                           'args': [('other',
                                                     'MQuaternion',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe quaternion addition operator.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The sum of the two quaternions ',
                                                          'qualifiers': [],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MQuaternion'}}],
                              '__eq__': [{'argInfo': {'other': {'doc': 'the quaternion to be compared with this quaternion',
                                                                'type': 'MQuaternion'}},
                                          'args': [('other',
                                                    'MQuaternion',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThe quaternion equality operator. This returns true if all four of the x, y, z, and w components are identical.',
                                          'inArgs': ['other'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true the quaternions are identical  false the quaternions are not identical   ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'other': ['const',
                                                                       '&']},
                                          'types': {'other': 'MQuaternion'}}],
                              '__getitem__': [{'argInfo': {'i': {'doc': 'value indicating which component to return',
                                                                 'type': 'uint'}},
                                               'args': [('i',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThe index operator. If its argument is 0 it will return the x component of the quaternion. If its argument is 1 it will return the y component of the quaternion. If its argument is 2 it will return the z component of the quaternion. If its argument is 3 it will return the w component of the quaternion.',
                                               'inArgs': ['i'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The component of the quaternion corresponding to the index ',
                                                              'qualifiers': [],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'i': ['unsigned']},
                                               'types': {'i': 'uint'}},
                                              {'argInfo': {'i': {'doc': 'value indicating which component to return',
                                                                 'type': 'uint'}},
                                               'args': [('i',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                               'inArgs': ['i'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the component of the quaternion corresponding to the index ',
                                                              'qualifiers': ['&'],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {'i': ['unsigned']},
                                               'types': {'i': 'uint'}}],
                              '__imul__': [{'argInfo': {'other': {'doc': 'the quaternion to be multiplied with this quaternion',
                                                                  'type': 'MQuaternion'}},
                                            'args': [('other',
                                                      'MQuaternion',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThe in place quaternion multiplication operator.',
                                            'inArgs': ['other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A reference to this quaternion which has been multiplied with the other quaternion ',
                                                           'qualifiers': ['&'],
                                                           'type': 'MQuaternion'},
                                            'returnType': 'MQuaternion',
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&']},
                                            'types': {'other': 'MQuaternion'}}],
                              '__mul__': [{'argInfo': {'other': {'doc': 'the quaternion to be multiplied with this quaternion',
                                                                 'type': 'MQuaternion'}},
                                           'args': [('other',
                                                     'MQuaternion',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThis quaternion multiplication operator.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The product of the two quaternions ',
                                                          'qualifiers': [],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MQuaternion'}},
                                          {'argInfo': {'other': {'doc': 'the quaternion to which the scale should be applied',
                                                                 'type': 'MQuaternion'},
                                                       'scale': {'doc': 'the amount by which the quaternion should be scaled ',
                                                                 'type': 'double'}},
                                           'args': [('scale',
                                                     'double',
                                                     'in'),
                                                    ('other',
                                                     'MQuaternion',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['scale', 'other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Quaternion that is the result of scaling the other quaternion ',
                                                          'qualifiers': ['MQuaternion'],
                                                          'type': ('MQuaternion',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MQuaternion',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&'],
                                                              'scale': []},
                                           'types': {'other': 'MQuaternion',
                                                     'scale': 'double'}}],
                              '__ne__': [{'argInfo': {'other': {'doc': 'the quaternion to be compared with this quaternion',
                                                                'type': 'MQuaternion'}},
                                          'args': [('other',
                                                    'MQuaternion',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThe quaternion inequality operator. This returns false if all four of the x, y, z, and w components are identical.',
                                          'inArgs': ['other'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': ' true the quaternions are not identical  false the quaternions are identical   ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'other': ['const',
                                                                       '&']},
                                          'types': {'other': 'MQuaternion'}}],
                              '__sub__': [{'argInfo': {'other': {'doc': 'the quaternion to be subtracted from this quaternion',
                                                                 'type': 'MQuaternion'}},
                                           'args': [('other',
                                                     'MQuaternion',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe quaternion subtraction operator.',
                                           'inArgs': ['other'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The quaternion that results from the subtraction ',
                                                          'qualifiers': [],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {'other': ['const',
                                                                        '&']},
                                           'types': {'other': 'MQuaternion'}},
                                          {'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe unary minus operator. Negates the value of each of the x, y, z, and w components of the quaternion.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asEulerRotation': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nConverts a quaternion to an euler rotation.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MEulerRotation'},
                                                   'returnType': 'MEulerRotation',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                              'asMatrix': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "\r\nConverts a quaternion to a 4X4 homogeneous rotation matrix. The construction of the matrix assumes that the vectors are going to be multiplied on the left side of the matrix. If the quaternion's length has degenerated, this method will still produce a well behaved matrix.",
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'MMatrix'},
                                            'returnType': 'MMatrix',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'conjugate': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the conjugate of this quaternion. The result is a quaternion whose x, y, and z values have been negated.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'MQuaternion'},
                                             'returnType': 'MQuaternion',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'conjugateIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nPerforms an in place conjugation of this quaternion. The result is a quaternion whose x, y, and z values have been negated.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['&'],
                                                              'type': 'MQuaternion'},
                                               'returnType': 'MQuaternion',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'dslerp': [{'argInfo': {'dir': {'doc': 'the direction of the interpolation',
                                                              'type': 'int'},
                                                      'p': {'doc': 'quaternion to rotate from ',
                                                            'type': 'MQuaternion'},
                                                      'q': {'doc': 'quaternion to rotate to ',
                                                            'type': 'MQuaternion'},
                                                      't': {'doc': 'interpolation value ',
                                                            'type': 'double'}},
                                          'args': [('p',
                                                    'MQuaternion',
                                                    'in'),
                                                   ('q',
                                                    'MQuaternion',
                                                    'in'),
                                                   ('t', 'double', 'in'),
                                                   ('dir', 'int', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                          'inArgs': ['p',
                                                     'q',
                                                     't',
                                                     'dir'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Quaternion that has been interpolated from p to q ',
                                                         'qualifiers': ['MQuaternion'],
                                                         'type': ('MQuaternion',
                                                                  'OPENMAYA_EXPORT')},
                                          'returnType': ('MQuaternion',
                                                         'OPENMAYA_EXPORT'),
                                          'static': False,
                                          'typeQualifiers': {'dir': [],
                                                             'p': ['const',
                                                                   '&'],
                                                             'q': ['const',
                                                                   '&'],
                                                             't': []},
                                          'types': {'dir': 'int',
                                                    'p': 'MQuaternion',
                                                    'q': 'MQuaternion',
                                                    't': 'double'}}],
                              'exp': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nExponentiates a quaternion that has a scalar part of zero. The precondition for using this method is that w is zero.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MQuaternion'},
                                       'returnType': 'MQuaternion',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                              'get': [{'argInfo': {'dest': {'doc': 'the array of 4 doubles into which the results are placed.',
                                                            'type': 'double__array4'}},
                                       'args': [('dest',
                                                 'double__array4',
                                                 'out')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nExtracts the x, y, z, and w components of the quaternion and places them in elements 0, 1, 2, and 3 of the double array passed.',
                                       'inArgs': [],
                                       'outArgs': ['dest'],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'dest': []},
                                       'types': {'dest': 'double__array4'}}],
                              'getAxisAngle': [{'argInfo': {'axis': {'doc': 'the axis about which the rotation occurs ',
                                                                     'type': 'MVector'},
                                                            'theta': {'doc': 'the angle of rotation about the axis in radians',
                                                                      'type': 'double'}},
                                                'args': [('axis',
                                                          'MVector',
                                                          'out'),
                                                         ('theta',
                                                          'double',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nConverts this quaternion into a user understandable representation. That is, the quaternion is represented as a pivot vector 'axis' and a rotation 'theta' (in radians) about that pivot vector.",
                                                'inArgs': [],
                                                'inverse': ('setAxisAngle',
                                                            False),
                                                'outArgs': ['axis',
                                                            'theta'],
                                                'returnInfo': {'doc': ' true angle != 0  false angle == 0 (uses arbitrary axis, if given axis not valid)   ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'axis': ['&'],
                                                                   'theta': ['&']},
                                                'types': {'axis': 'MVector',
                                                          'theta': 'double'}}],
                              'inverse': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the inverse of this quaternion.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'invertIt': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nPerforms an in place inversion of this quaternion.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['&'],
                                                           'type': 'MQuaternion'},
                                            'returnType': 'MQuaternion',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'isEquivalent': [{'argInfo': {'other': {'doc': 'the quaternion to be compared with this quaternion ',
                                                                      'type': 'MQuaternion'},
                                                            'tolerance': {'doc': 'the amount of variation allowed for equivalency',
                                                                          'type': 'double'}},
                                                'args': [('other',
                                                          'MQuaternion',
                                                          'in'),
                                                         ('tolerance',
                                                          'double',
                                                          'in')],
                                                'defaults': {'tolerance': 1e-10},
                                                'deprecated': False,
                                                'doc': '\r\nThis method returns true if this quaternion is equal, within some given tolerance, to the other quaternion.',
                                                'inArgs': ['other',
                                                           'tolerance'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': ' true the quaternions are equivalent  false the quaternions are not equivalent   ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'other': ['const',
                                                                             '&'],
                                                                   'tolerance': []},
                                                'types': {'other': 'MQuaternion',
                                                          'tolerance': 'double'}}],
                              'log': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns the natural log of a quaternion. The precondition for using this method is that the quaternion must be normalized.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MQuaternion'},
                                       'returnType': 'MQuaternion',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                              'negateIt': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nPerforms an in place negation of the quaternion. The result is a quaternion whose x, y, z, and w values have been negated.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['&'],
                                                           'type': 'MQuaternion'},
                                            'returnType': 'MQuaternion',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'normal': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the normal of this quaternion. The result is a quaternion of unit length.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'MQuaternion'},
                                          'returnType': 'MQuaternion',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'normalizeIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nPerforms an in place normalization of this quaternion. The result is a quaternion of unit length.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['&'],
                                                              'type': 'MQuaternion'},
                                               'returnType': 'MQuaternion',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'scaleIt': [{'argInfo': {'scale': {'doc': 'the amount by which the quaternion should be scaled',
                                                                 'type': 'double'}},
                                           'args': [('scale',
                                                     'double',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nPerforms an in place scaling of the quaternion. The result is a quaternion whose x, y, z, and w values have been scaled by the specified amount.',
                                           'inArgs': ['scale'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A reference to the quaternion that has been scaled ',
                                                          'qualifiers': ['&'],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {'scale': []},
                                           'types': {'scale': 'double'}}],
                              'setAxisAngle': [{'argInfo': {'axis': {'doc': 'the axis about which to rotate ',
                                                                     'type': 'MVector'},
                                                            'theta': {'doc': 'the angle of rotation about the axis in radians',
                                                                      'type': 'double'}},
                                                'args': [('axis',
                                                          'MVector',
                                                          'in'),
                                                         ('theta',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets this quaternion to be the rotation as expressed by a pivot axis and a rotation theta (in radians) about that axis. If the axis is too small the quaternion returned will be the identity quaternion.',
                                                'inArgs': ['axis',
                                                           'theta'],
                                                'inverse': ('getAxisAngle',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the quaternion that has had its axis and angle set ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MQuaternion'},
                                                'returnType': 'MQuaternion',
                                                'static': False,
                                                'typeQualifiers': {'axis': ['const',
                                                                            '&'],
                                                                   'theta': []},
                                                'types': {'axis': 'MVector',
                                                          'theta': 'double'}}],
                              'setToXAxis': [{'argInfo': {'theta': {'doc': 'the angle of rotation about the X axis in radians',
                                                                    'type': 'double'}},
                                              'args': [('theta',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets this quaternion to be the rotation about the X axis of theta (in radians). If the length of the axis is too small the quaternion returned will be the identity quaternion.',
                                              'inArgs': ['theta'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A reference to the quaternion that has been set to rotate about the X axis by the given amount ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MQuaternion'},
                                              'returnType': 'MQuaternion',
                                              'static': False,
                                              'typeQualifiers': {'theta': []},
                                              'types': {'theta': 'double'}}],
                              'setToYAxis': [{'argInfo': {'theta': {'doc': 'the angle of rotation about the Y axis in radians',
                                                                    'type': 'double'}},
                                              'args': [('theta',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets this quaternion to be the rotation about the Y axis of theta (in radians). If the length of the axis is too small the quaternion returned will be the identity quaternion.',
                                              'inArgs': ['theta'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A reference to the quaternion that has been set to rotate about the Y axis by the given amount ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MQuaternion'},
                                              'returnType': 'MQuaternion',
                                              'static': False,
                                              'typeQualifiers': {'theta': []},
                                              'types': {'theta': 'double'}}],
                              'setToZAxis': [{'argInfo': {'theta': {'doc': 'the angle of rotation about the Z axis in radians',
                                                                    'type': 'double'}},
                                              'args': [('theta',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets this quaternion to be the rotation about the Z axis of theta (in radians). If the length of the axis is too small the quaternion returned will be the identity quaternion.',
                                              'inArgs': ['theta'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A reference to the quaternion that has been set to rotate about the Z axis by the given amount ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MQuaternion'},
                                              'returnType': 'MQuaternion',
                                              'static': False,
                                              'typeQualifiers': {'theta': []},
                                              'types': {'theta': 'double'}}],
                              'slerp': [{'argInfo': {'p': {'doc': 'quaternion to rotate from ',
                                                           'type': 'MQuaternion'},
                                                     'q': {'doc': 'quaternion to rotate to ',
                                                           'type': 'MQuaternion'},
                                                     't': {'doc': 'interpolation value',
                                                           'type': 'double'}},
                                         'args': [('p',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('q',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('t', 'double', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nSpherical linear interpolation (abbreviated as slerp) of unit quaternions. As t goes from 0 to 1, the quaternion returned goes from p to q. The interpolation always takes shortest path (in quaternion space) from p to q.',
                                         'inArgs': ['p', 'q', 't'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Quaternion that has been interpolated from p to q ',
                                                        'qualifiers': ['MQuaternion'],
                                                        'type': ('MQuaternion',
                                                                 'OPENMAYA_EXPORT')},
                                         'returnType': ('MQuaternion',
                                                        'OPENMAYA_EXPORT'),
                                         'static': False,
                                         'typeQualifiers': {'p': ['const',
                                                                  '&'],
                                                            'q': ['const',
                                                                  '&'],
                                                            't': []},
                                         'types': {'p': 'MQuaternion',
                                                   'q': 'MQuaternion',
                                                   't': 'double'}},
                                        {'argInfo': {'p': {'doc': 'quaternion to rotate from ',
                                                           'type': 'MQuaternion'},
                                                     'q': {'doc': 'quaternion to rotate to ',
                                                           'type': 'MQuaternion'},
                                                     'spin': {'doc': 'the number of complete revolutions around the axis',
                                                              'type': 'short'},
                                                     't': {'doc': 'interpolation value ',
                                                           'type': 'double'}},
                                         'args': [('p',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('q',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('t', 'double', 'in'),
                                                  ('spin',
                                                   'short',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                         'inArgs': ['p',
                                                    'q',
                                                    't',
                                                    'spin'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Quaternion that has been interpolated from p to q ',
                                                        'qualifiers': ['MQuaternion'],
                                                        'type': ('MQuaternion',
                                                                 'OPENMAYA_EXPORT')},
                                         'returnType': ('MQuaternion',
                                                        'OPENMAYA_EXPORT'),
                                         'static': False,
                                         'typeQualifiers': {'p': ['const',
                                                                  '&'],
                                                            'q': ['const',
                                                                  '&'],
                                                            'spin': [],
                                                            't': []},
                                         'types': {'p': 'MQuaternion',
                                                   'q': 'MQuaternion',
                                                   'spin': 'short',
                                                   't': 'double'}}],
                              'squad': [{'argInfo': {'a': {'doc': 'intermediate squad point ',
                                                           'type': 'MQuaternion'},
                                                     'b': {'doc': 'intermediate squad point ',
                                                           'type': 'MQuaternion'},
                                                     'p': {'doc': 'quaternion to rotate from ',
                                                           'type': 'MQuaternion'},
                                                     'q': {'doc': 'quaternion to rotate to ',
                                                           'type': 'MQuaternion'},
                                                     't': {'doc': 'interpolation value',
                                                           'type': 'double'}},
                                         'args': [('p',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('a',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('b',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('q',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('t', 'double', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                         'inArgs': ['p',
                                                    'a',
                                                    'b',
                                                    'q',
                                                    't'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Quaternion that has been interpolated from p to q ',
                                                        'qualifiers': ['MQuaternion'],
                                                        'type': ('MQuaternion',
                                                                 'OPENMAYA_EXPORT')},
                                         'returnType': ('MQuaternion',
                                                        'OPENMAYA_EXPORT'),
                                         'static': False,
                                         'typeQualifiers': {'a': ['const',
                                                                  '&'],
                                                            'b': ['const',
                                                                  '&'],
                                                            'p': ['const',
                                                                  '&'],
                                                            'q': ['const',
                                                                  '&'],
                                                            't': []},
                                         'types': {'a': 'MQuaternion',
                                                   'b': 'MQuaternion',
                                                   'p': 'MQuaternion',
                                                   'q': 'MQuaternion',
                                                   't': 'double'}},
                                        {'argInfo': {'a': {'doc': 'intermediate squad point ',
                                                           'type': 'MQuaternion'},
                                                     'b': {'doc': 'intermediate squad point ',
                                                           'type': 'MQuaternion'},
                                                     'p': {'doc': 'quaternion to rotate from ',
                                                           'type': 'MQuaternion'},
                                                     'q': {'doc': 'quaternion to rotate to ',
                                                           'type': 'MQuaternion'},
                                                     'spin': {'doc': 'number of full spins',
                                                              'type': 'short'},
                                                     't': {'doc': 'interpolation value ',
                                                           'type': 'double'}},
                                         'args': [('p',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('a',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('b',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('q',
                                                   'MQuaternion',
                                                   'in'),
                                                  ('t', 'double', 'in'),
                                                  ('spin',
                                                   'short',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                         'inArgs': ['p',
                                                    'a',
                                                    'b',
                                                    'q',
                                                    't',
                                                    'spin'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Quaternion that has been interpolated from p to q ',
                                                        'qualifiers': ['MQuaternion'],
                                                        'type': ('MQuaternion',
                                                                 'OPENMAYA_EXPORT')},
                                         'returnType': ('MQuaternion',
                                                        'OPENMAYA_EXPORT'),
                                         'static': False,
                                         'typeQualifiers': {'a': ['const',
                                                                  '&'],
                                                            'b': ['const',
                                                                  '&'],
                                                            'p': ['const',
                                                                  '&'],
                                                            'q': ['const',
                                                                  '&'],
                                                            'spin': [],
                                                            't': []},
                                         'types': {'a': 'MQuaternion',
                                                   'b': 'MQuaternion',
                                                   'p': 'MQuaternion',
                                                   'q': 'MQuaternion',
                                                   'spin': 'short',
                                                   't': 'double'}}],
                              'squadPt': [{'argInfo': {'q0': {'doc': 'quaternion from which the squad is computed ',
                                                              'type': 'MQuaternion'},
                                                       'q1': {'doc': 'quaternion from which the squad is computed ',
                                                              'type': 'MQuaternion'},
                                                       'q2': {'doc': 'quaternion from which the squad is computed',
                                                              'type': 'MQuaternion'}},
                                           'args': [('q0',
                                                     'MQuaternion',
                                                     'in'),
                                                    ('q1',
                                                     'MQuaternion',
                                                     'in'),
                                                    ('q2',
                                                     'MQuaternion',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['q0', 'q1', 'q2'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Unit quaternion resulting from the squad computation ',
                                                          'qualifiers': ['MQuaternion'],
                                                          'type': ('MQuaternion',
                                                                   'OPENMAYA_EXPORT')},
                                           'returnType': ('MQuaternion',
                                                          'OPENMAYA_EXPORT'),
                                           'static': False,
                                           'typeQualifiers': {'q0': ['const',
                                                                     '&'],
                                                              'q1': ['const',
                                                                     '&'],
                                                              'q2': ['const',
                                                                     '&']},
                                           'types': {'q0': 'MQuaternion',
                                                     'q1': 'MQuaternion',
                                                     'q2': 'MQuaternion'}}]},
                  'pymelEnums': {}},
  'MRampAttribute': {'enums': {'MInterpolation': {'valueDocs': {'kLinear': '',
                                                                'kNone': '',
                                                                'kSmooth': '',
                                                                'kSpline': '',
                                                                'linear': '',
                                                                'none': '',
                                                                'smooth': '',
                                                                'spline': ''},
                                                  'values': "Enum('MInterpolation', {'kNone': 0, 'kLinear': 1, 'kSmooth': 2, 'kSpline': 3})"}},
                     'methods': {'addEntries': [{'argInfo': {'colors': {'doc': 'the colors of the new entries at each position ',
                                                                        'type': 'MColorArray'},
                                                             'interps': {'doc': 'array of MRampAttribute::MInterpolation values giving the interpolations of the entries at each position. ',
                                                                         'type': 'MIntArray'},
                                                             'positions': {'doc': 'the positions of the new entries (can range from 0 to 1) ',
                                                                           'type': 'MFloatArray'}},
                                                 'args': [('positions',
                                                           'MFloatArray',
                                                           'in'),
                                                          ('colors',
                                                           'MColorArray',
                                                           'in'),
                                                          ('interps',
                                                           'MIntArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdds entries into a ramp attribute. If the ramp is a curve ramp, then this function will return a failure.',
                                                 'inArgs': ['positions',
                                                            'colors',
                                                            'interps'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'colors': ['&'],
                                                                    'interps': ['&'],
                                                                    'positions': ['&']},
                                                 'types': {'colors': 'MColorArray',
                                                           'interps': 'MIntArray',
                                                           'positions': 'MFloatArray'}},
                                                {'argInfo': {'interps': {'doc': 'array of MRampAttribute::MInterpolation values giving the interpolations of the entries at each position. ',
                                                                         'type': 'MIntArray'},
                                                             'positions': {'doc': 'the positions of the new entries (can range from 0 to 1) ',
                                                                           'type': 'MFloatArray'},
                                                             'values': {'doc': 'the values of the new entry at each position ',
                                                                        'type': 'MFloatArray'}},
                                                 'args': [('positions',
                                                           'MFloatArray',
                                                           'in'),
                                                          ('values',
                                                           'MFloatArray',
                                                           'in'),
                                                          ('interps',
                                                           'MIntArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdds entries into a ramp attribute. If the ramp is a color ramp, then this function will return a failure.',
                                                 'inArgs': ['positions',
                                                            'values',
                                                            'interps'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'interps': ['&'],
                                                                    'positions': ['&'],
                                                                    'values': ['&']},
                                                 'types': {'interps': 'MIntArray',
                                                           'positions': 'MFloatArray',
                                                           'values': 'MFloatArray'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'createColorRamp': [{'argInfo': {'attrLongName': {'doc': 'Long name of the curve ramp attribute ',
                                                                                   'type': 'MString'},
                                                                  'attrShortName': {'doc': 'Short name of the curve ramp attribute ',
                                                                                    'type': 'MString'}},
                                                      'args': [('attrLongName',
                                                                'MString',
                                                                'in'),
                                                               ('attrShortName',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis function creates the color ramp attribute.',
                                                      'inArgs': ['attrLongName',
                                                                 'attrShortName'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Color ramp attribute, returned as MObject.',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'attrLongName': ['const',
                                                                                          '&'],
                                                                         'attrShortName': ['const',
                                                                                           '&']},
                                                      'types': {'attrLongName': 'MString',
                                                                'attrShortName': 'MString'}}],
                                 'createCurveRamp': [{'argInfo': {'attrLongName': {'doc': 'Long name of the curve ramp attribute ',
                                                                                   'type': 'MString'},
                                                                  'attrShortName': {'doc': 'Short name of the curve ramp attribute ',
                                                                                    'type': 'MString'}},
                                                      'args': [('attrLongName',
                                                                'MString',
                                                                'in'),
                                                               ('attrShortName',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis function creates the curve ramp attribute.',
                                                      'inArgs': ['attrLongName',
                                                                 'attrShortName'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Curve ramp attribute, returned as MObject.',
                                                                     'qualifiers': [],
                                                                     'type': 'MObject'},
                                                      'returnType': 'MObject',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'attrLongName': ['const',
                                                                                          '&'],
                                                                         'attrShortName': ['const',
                                                                                           '&']},
                                                      'types': {'attrLongName': 'MString',
                                                                'attrShortName': 'MString'}}],
                                 'createRamp': [{'argInfo': {'attrLongName': {'doc': 'Long name of the new curve ramp attribute ',
                                                                              'type': 'MString'},
                                                             'attrShortName': {'doc': 'Short name of the new curve ramp attribute ',
                                                                               'type': 'MString'},
                                                             'interp': {'doc': 'Interpolation value (defaults to MInterpolation::kLinear) ',
                                                                        'type': ('MRampAttribute',
                                                                                 'MInterpolation')},
                                                             'node': {'doc': 'The node to which the new ramp attribute will be added ',
                                                                      'type': 'MObject'},
                                                             'position': {'doc': 'Desired position (defaults to 1.0) ',
                                                                          'type': 'float'},
                                                             'value': {'doc': 'Float value ',
                                                                       'type': 'float'}},
                                                 'args': [('attrLongName',
                                                           'MString',
                                                           'in'),
                                                          ('attrShortName',
                                                           'MString',
                                                           'in'),
                                                          ('node',
                                                           'MObject',
                                                           'in'),
                                                          ('value',
                                                           'float',
                                                           'in'),
                                                          ('position',
                                                           'float',
                                                           'in'),
                                                          ('interp',
                                                           ('MRampAttribute',
                                                            'MInterpolation'),
                                                           'in')],
                                                 'defaults': {'interp': ('MRampAttribute',
                                                                         'MInterpolation',
                                                                         'kLinear'),
                                                              'position': '1.f'},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreates a new curve ramp attribute initialized with an entry defined from a float, position and interpolation value.',
                                                 'inArgs': ['attrLongName',
                                                            'attrShortName',
                                                            'node',
                                                            'value',
                                                            'position',
                                                            'interp'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'attrLongName': ['const',
                                                                                     '&'],
                                                                    'attrShortName': ['const',
                                                                                      '&'],
                                                                    'interp': [],
                                                                    'node': ['const',
                                                                             '&'],
                                                                    'position': [],
                                                                    'value': []},
                                                 'types': {'attrLongName': 'MString',
                                                           'attrShortName': 'MString',
                                                           'interp': ('MRampAttribute',
                                                                      'MInterpolation'),
                                                           'node': 'MObject',
                                                           'position': 'float',
                                                           'value': 'float'}},
                                                {'argInfo': {'attrLongName': {'doc': 'Long name of the new curve ramp attribute ',
                                                                              'type': 'MString'},
                                                             'attrShortName': {'doc': 'Short name of the new curve ramp attribute ',
                                                                               'type': 'MString'},
                                                             'color': {'doc': 'MColor value ',
                                                                       'type': 'MColor'},
                                                             'interp': {'doc': 'Interpolation value (defaults to MInterpolation::kLinear) ',
                                                                        'type': ('MRampAttribute',
                                                                                 'MInterpolation')},
                                                             'node': {'doc': 'The node to which the new ramp attribute will be added ',
                                                                      'type': 'MObject'},
                                                             'position': {'doc': 'Desired position (defaults to 1.0) ',
                                                                          'type': 'float'}},
                                                 'args': [('attrLongName',
                                                           'MString',
                                                           'in'),
                                                          ('attrShortName',
                                                           'MString',
                                                           'in'),
                                                          ('node',
                                                           'MObject',
                                                           'in'),
                                                          ('color',
                                                           'MColor',
                                                           'in'),
                                                          ('position',
                                                           'float',
                                                           'in'),
                                                          ('interp',
                                                           ('MRampAttribute',
                                                            'MInterpolation'),
                                                           'in')],
                                                 'defaults': {'interp': ('MRampAttribute',
                                                                         'MInterpolation',
                                                                         'kLinear'),
                                                              'position': '1.0f'},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreates a new color ramp attribute initialized with one entry defined from a color, position and interpolation value.',
                                                 'inArgs': ['attrLongName',
                                                            'attrShortName',
                                                            'node',
                                                            'color',
                                                            'position',
                                                            'interp'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'attrLongName': ['const',
                                                                                     '&'],
                                                                    'attrShortName': ['const',
                                                                                      '&'],
                                                                    'color': ['const',
                                                                              '&'],
                                                                    'interp': [],
                                                                    'node': ['const',
                                                                             '&'],
                                                                    'position': []},
                                                 'types': {'attrLongName': 'MString',
                                                           'attrShortName': 'MString',
                                                           'color': 'MColor',
                                                           'interp': ('MRampAttribute',
                                                                      'MInterpolation'),
                                                           'node': 'MObject',
                                                           'position': 'float'}},
                                                {'argInfo': {'attrLongName': {'doc': 'Long name of the new curve ramp attribute ',
                                                                              'type': 'MString'},
                                                             'attrShortName': {'doc': 'Short name of the new curve ramp attribute ',
                                                                               'type': 'MString'},
                                                             'interps': {'doc': 'Array of interpolation values. ',
                                                                         'type': 'MIntArray'},
                                                             'node': {'doc': 'The node to which the new ramp attribute will be added ',
                                                                      'type': 'MObject'},
                                                             'positions': {'doc': 'Array of desired positions. ',
                                                                           'type': 'MFloatArray'},
                                                             'values': {'doc': 'Array of float value. ',
                                                                        'type': 'MFloatArray'}},
                                                 'args': [('attrLongName',
                                                           'MString',
                                                           'in'),
                                                          ('attrShortName',
                                                           'MString',
                                                           'in'),
                                                          ('node',
                                                           'MObject',
                                                           'in'),
                                                          ('values',
                                                           'MFloatArray',
                                                           'in'),
                                                          ('positions',
                                                           'MFloatArray',
                                                           'in'),
                                                          ('interps',
                                                           'MIntArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreates a new curve ramp attribute initialized with entries defined from a set of float, position and interpolation value arrays.',
                                                 'inArgs': ['attrLongName',
                                                            'attrShortName',
                                                            'node',
                                                            'values',
                                                            'positions',
                                                            'interps'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'attrLongName': ['const',
                                                                                     '&'],
                                                                    'attrShortName': ['const',
                                                                                      '&'],
                                                                    'interps': ['const',
                                                                                '&'],
                                                                    'node': ['const',
                                                                             '&'],
                                                                    'positions': ['const',
                                                                                  '&'],
                                                                    'values': ['const',
                                                                               '&']},
                                                 'types': {'attrLongName': 'MString',
                                                           'attrShortName': 'MString',
                                                           'interps': 'MIntArray',
                                                           'node': 'MObject',
                                                           'positions': 'MFloatArray',
                                                           'values': 'MFloatArray'}},
                                                {'argInfo': {'attrLongName': {'doc': 'Long name of the new curve ramp attribute ',
                                                                              'type': 'MString'},
                                                             'attrShortName': {'doc': 'Short name of the new curve ramp attribute ',
                                                                               'type': 'MString'},
                                                             'colors': {'doc': 'Array of color values ',
                                                                        'type': 'MColorArray'},
                                                             'interps': {'doc': 'Array of interpolation values ',
                                                                         'type': 'MIntArray'},
                                                             'node': {'doc': 'The node to which the new ramp attribute will be added ',
                                                                      'type': 'MObject'},
                                                             'positions': {'doc': 'Array of desired positions ',
                                                                           'type': 'MFloatArray'}},
                                                 'args': [('attrLongName',
                                                           'MString',
                                                           'in'),
                                                          ('attrShortName',
                                                           'MString',
                                                           'in'),
                                                          ('node',
                                                           'MObject',
                                                           'in'),
                                                          ('colors',
                                                           'MColorArray',
                                                           'in'),
                                                          ('positions',
                                                           'MFloatArray',
                                                           'in'),
                                                          ('interps',
                                                           'MIntArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCreates a new curve ramp attribute initialized with entries defined from a set of color, position and interpolation value arrays.',
                                                 'inArgs': ['attrLongName',
                                                            'attrShortName',
                                                            'node',
                                                            'colors',
                                                            'positions',
                                                            'interps'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'attrLongName': ['const',
                                                                                     '&'],
                                                                    'attrShortName': ['const',
                                                                                      '&'],
                                                                    'colors': ['const',
                                                                               '&'],
                                                                    'interps': ['const',
                                                                                '&'],
                                                                    'node': ['const',
                                                                             '&'],
                                                                    'positions': ['const',
                                                                                  '&']},
                                                 'types': {'attrLongName': 'MString',
                                                           'attrShortName': 'MString',
                                                           'colors': 'MColorArray',
                                                           'interps': 'MIntArray',
                                                           'node': 'MObject',
                                                           'positions': 'MFloatArray'}}],
                                 'deleteEntries': [{'argInfo': {'indices': {'doc': 'the entries that need to be deleted ',
                                                                            'type': 'MIntArray'}},
                                                    'args': [('indices',
                                                              'MIntArray',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nDeletes entries in the ramp attribute.',
                                                    'inArgs': ['indices'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'indices': ['&']},
                                                    'types': {'indices': 'MIntArray'}}],
                                 'getColorAtPosition': [{'argInfo': {'color': {'doc': 'the color at the position ',
                                                                               'type': 'MColor'},
                                                                     'position': {'doc': 'the desired position ',
                                                                                  'type': 'float'}},
                                                         'args': [('position',
                                                                   'float',
                                                                   'in'),
                                                                  ('color',
                                                                   'MColor',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGets the color at a position in the current evaluation context',
                                                         'inArgs': ['position'],
                                                         'outArgs': ['color'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'color': ['&'],
                                                                            'position': []},
                                                         'types': {'color': 'MColor',
                                                                   'position': 'float'}}],
                                 'getEntries': [{'argInfo': {'indices': {'doc': 'unique values that specify each entry in the ramp ',
                                                                         'type': 'MIntArray'},
                                                             'interps': {'doc': 'array of MRampAttribute::MInterpolation values giving the interpolations of the entries at each position. ',
                                                                         'type': 'MIntArray'},
                                                             'positions': {'doc': 'the positions of each entry (can range from 0 to 1) ',
                                                                           'type': 'MFloatArray'},
                                                             'values': {'doc': 'the values of the entries at each position (can range from 0 to 1) ',
                                                                        'type': 'MFloatArray'}},
                                                 'args': [('indices',
                                                           'MIntArray',
                                                           'out'),
                                                          ('positions',
                                                           'MFloatArray',
                                                           'out'),
                                                          ('values',
                                                           'MFloatArray',
                                                           'out'),
                                                          ('interps',
                                                           'MIntArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGets all the entries in a ramp attribute. If the ramp is a color ramp, then this function will return a failure.',
                                                 'inArgs': [],
                                                 'outArgs': ['indices',
                                                             'positions',
                                                             'values',
                                                             'interps'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'indices': ['&'],
                                                                    'interps': ['&'],
                                                                    'positions': ['&'],
                                                                    'values': ['&']},
                                                 'types': {'indices': 'MIntArray',
                                                           'interps': 'MIntArray',
                                                           'positions': 'MFloatArray',
                                                           'values': 'MFloatArray'}},
                                                {'argInfo': {'colors': {'doc': 'the colors of the entries at each position ',
                                                                        'type': 'MColorArray'},
                                                             'indices': {'doc': 'unique values that specify each entry in the ramp ',
                                                                         'type': 'MIntArray'},
                                                             'interps': {'doc': 'array of MRampAttribute::MInterpolation values giving the interpolations of the entries at each position. ',
                                                                         'type': 'MIntArray'},
                                                             'positions': {'doc': 'the positions of each entry (can range from 0 to 1) ',
                                                                           'type': 'MFloatArray'}},
                                                 'args': [('indices',
                                                           'MIntArray',
                                                           'out'),
                                                          ('positions',
                                                           'MFloatArray',
                                                           'out'),
                                                          ('colors',
                                                           'MColorArray',
                                                           'out'),
                                                          ('interps',
                                                           'MIntArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGets all the entries in a ramp attribute. If the ramp is a curve ramp, then this function will return a failure.',
                                                 'inArgs': [],
                                                 'outArgs': ['indices',
                                                             'positions',
                                                             'colors',
                                                             'interps'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'colors': ['&'],
                                                                    'indices': ['&'],
                                                                    'interps': ['&'],
                                                                    'positions': ['&']},
                                                 'types': {'colors': 'MColorArray',
                                                           'indices': 'MIntArray',
                                                           'interps': 'MIntArray',
                                                           'positions': 'MFloatArray'}}],
                                 'getNumEntries': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGets the number of entries in the ramp attribute.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The number of entries in the ramp attribute ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*']},
                                                    'types': {}}],
                                 'getValueAtPosition': [{'argInfo': {'position': {'doc': 'the desired position ',
                                                                                  'type': 'float'},
                                                                     'value': {'doc': 'the value at the position ',
                                                                               'type': 'float'}},
                                                         'args': [('position',
                                                                   'float',
                                                                   'in'),
                                                                  ('value',
                                                                   'float',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGets the value at position in the current evaluation context',
                                                         'inArgs': ['position'],
                                                         'outArgs': ['value'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'position': [],
                                                                            'value': ['&']},
                                                         'types': {'position': 'float',
                                                                   'value': 'float'}}],
                                 'hasIndex': [{'argInfo': {'index': {'doc': 'Index to query. ',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns true if this ramp attribute has an entry defined with a given index.',
                                               'inArgs': ['index'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'True if the index exists, false otherwise.',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                  'index': ['unsigned']},
                                               'types': {'index': 'uint'}}],
                                 'isColorRamp': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nChecks to see whether this ramp is a color ramp.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the ramp is a color ramp, false otherwise',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'isCurveRamp': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nChecks to see whether this ramp is a curve ramp.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the ramp is a curve ramp, false otherwise',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                                  'types': {}}],
                                 'pack': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nChange the indices numbering by re-ordering them from 0.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                 'sampleColorRamp': [{'argInfo': {'colors': {'doc': 'The returned ramp samples ',
                                                                             'type': 'MColorArray'},
                                                                  'numberOfSamples': {'doc': 'The number of times to sample the ramp ',
                                                                                      'type': 'uint'}},
                                                      'args': [('numberOfSamples',
                                                                'uint',
                                                                'in'),
                                                               ('colors',
                                                                'MColorArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nPerform a linear sampling of this color ramp at the current evaluation context and return the results.',
                                                      'inArgs': ['numberOfSamples'],
                                                      'outArgs': ['colors'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'colors': ['&'],
                                                                         'numberOfSamples': ['unsigned']},
                                                      'types': {'colors': 'MColorArray',
                                                                'numberOfSamples': 'uint'}}],
                                 'sampleValueRamp': [{'argInfo': {'numberOfSamples': {'doc': 'The number of times to sample the ramp ',
                                                                                      'type': 'uint'},
                                                                  'values': {'doc': 'The returned ramp samples ',
                                                                             'type': 'MFloatArray'}},
                                                      'args': [('numberOfSamples',
                                                                'uint',
                                                                'in'),
                                                               ('values',
                                                                'MFloatArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nPerform a linear sampling of this curve ramp in the current evaluation context and return the results.',
                                                      'inArgs': ['numberOfSamples'],
                                                      'outArgs': ['values'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'numberOfSamples': ['unsigned'],
                                                                         'values': ['&']},
                                                      'types': {'numberOfSamples': 'uint',
                                                                'values': 'MFloatArray'}}],
                                 'setColorAtIndex': [{'argInfo': {'color': {'doc': 'the new color for the entry ',
                                                                            'type': 'MColor'},
                                                                  'index': {'doc': 'index of entry to change ',
                                                                            'type': 'uint'}},
                                                      'args': [('color',
                                                                'MColor',
                                                                'in'),
                                                               ('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the color of a given entry',
                                                      'inArgs': ['color',
                                                                 'index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'color': ['&'],
                                                                         'index': ['unsigned']},
                                                      'types': {'color': 'MColor',
                                                                'index': 'uint'}}],
                                 'setInterpolationAtIndex': [{'argInfo': {'index': {'doc': 'index of entry to change ',
                                                                                    'type': 'uint'},
                                                                          'interp': {'doc': 'the new interpolation for the entry ',
                                                                                     'type': ('MRampAttribute',
                                                                                              'MInterpolation')}},
                                                              'args': [('interp',
                                                                        ('MRampAttribute',
                                                                         'MInterpolation'),
                                                                        'in'),
                                                                       ('index',
                                                                        'uint',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nSets the interpolation of a given entry',
                                                              'inArgs': ['interp',
                                                                         'index'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'index': ['unsigned'],
                                                                                 'interp': []},
                                                              'types': {'index': 'uint',
                                                                        'interp': ('MRampAttribute',
                                                                                   'MInterpolation')}}],
                                 'setPositionAtIndex': [{'argInfo': {'index': {'doc': 'index of entry to change ',
                                                                               'type': 'uint'},
                                                                     'position': {'doc': 'the new position for the entry ',
                                                                                  'type': 'float'}},
                                                         'args': [('position',
                                                                   'float',
                                                                   'in'),
                                                                  ('index',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the position of a given entry',
                                                         'inArgs': ['position',
                                                                    'index'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'index': ['unsigned'],
                                                                            'position': []},
                                                         'types': {'index': 'uint',
                                                                   'position': 'float'}}],
                                 'setRamp': [{'argInfo': {'interp': {'doc': 'Interpolation value (defaults to MInterpolation::kLinear)',
                                                                     'type': ('MRampAttribute',
                                                                              'MInterpolation')},
                                                          'position': {'doc': 'Desired position (defaults to 1.0) ',
                                                                       'type': 'float'},
                                                          'value': {'doc': 'Float value ',
                                                                    'type': 'float'}},
                                              'args': [('value',
                                                        'float',
                                                        'in'),
                                                       ('position',
                                                        'float',
                                                        'in'),
                                                       ('interp',
                                                        ('MRampAttribute',
                                                         'MInterpolation'),
                                                        'in')],
                                              'defaults': {'interp': ('MRampAttribute',
                                                                      'MInterpolation',
                                                                      'kLinear'),
                                                           'position': '1.0f'},
                                              'deprecated': False,
                                              'doc': '\r\nSets this ramp attribute with one entry defined from a float, position and interpolation value. Existing entries are deleted before the new one is added.',
                                              'inArgs': ['value',
                                                         'position',
                                                         'interp'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'interp': [],
                                                                 'position': [],
                                                                 'value': []},
                                              'types': {'interp': ('MRampAttribute',
                                                                   'MInterpolation'),
                                                        'position': 'float',
                                                        'value': 'float'}},
                                             {'argInfo': {'color': {'doc': 'Color value ',
                                                                    'type': 'MColor'},
                                                          'interp': {'doc': 'Interpolation value (defaults to MInterpolation::kLinear)',
                                                                     'type': ('MRampAttribute',
                                                                              'MInterpolation')},
                                                          'position': {'doc': 'Desired position (defaults to 1.0) ',
                                                                       'type': 'float'}},
                                              'args': [('color',
                                                        'MColor',
                                                        'in'),
                                                       ('position',
                                                        'float',
                                                        'in'),
                                                       ('interp',
                                                        ('MRampAttribute',
                                                         'MInterpolation'),
                                                        'in')],
                                              'defaults': {'interp': ('MRampAttribute',
                                                                      'MInterpolation',
                                                                      'kLinear'),
                                                           'position': '1.0f'},
                                              'deprecated': False,
                                              'doc': '\r\nSets this ramp attribute with one entry defined from a color, position and interpolation value. Existing entries are deleted before the new one is added.',
                                              'inArgs': ['color',
                                                         'position',
                                                         'interp'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'color': ['const',
                                                                           '&'],
                                                                 'interp': [],
                                                                 'position': []},
                                              'types': {'color': 'MColor',
                                                        'interp': ('MRampAttribute',
                                                                   'MInterpolation'),
                                                        'position': 'float'}},
                                             {'argInfo': {'interps': {'doc': 'Array of interpolation values.',
                                                                      'type': 'MIntArray'},
                                                          'positions': {'doc': 'Array of desired positions. ',
                                                                        'type': 'MFloatArray'},
                                                          'values': {'doc': 'Array of float value. ',
                                                                     'type': 'MFloatArray'}},
                                              'args': [('values',
                                                        'MFloatArray',
                                                        'in'),
                                                       ('positions',
                                                        'MFloatArray',
                                                        'in'),
                                                       ('interps',
                                                        'MIntArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets this ramp attribute with entries defined from a set of float, position and interpolation value arrays. Existing entries are deleted before the new ones are added.',
                                              'inArgs': ['values',
                                                         'positions',
                                                         'interps'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'interps': ['const',
                                                                             '&'],
                                                                 'positions': ['const',
                                                                               '&'],
                                                                 'values': ['const',
                                                                            '&']},
                                              'types': {'interps': 'MIntArray',
                                                        'positions': 'MFloatArray',
                                                        'values': 'MFloatArray'}},
                                             {'argInfo': {'colors': {'doc': 'Array of color values. ',
                                                                     'type': 'MColorArray'},
                                                          'interps': {'doc': 'Array of interpolation values.',
                                                                      'type': 'MIntArray'},
                                                          'positions': {'doc': 'Array of desired positions. ',
                                                                        'type': 'MFloatArray'}},
                                              'args': [('colors',
                                                        'MColorArray',
                                                        'in'),
                                                       ('positions',
                                                        'MFloatArray',
                                                        'in'),
                                                       ('interps',
                                                        'MIntArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets this ramp attribute with entries defined from a set of color, position and interpolation value arrays. Existing entries are deleted before the new ones are added.',
                                              'inArgs': ['colors',
                                                         'positions',
                                                         'interps'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'colors': ['const',
                                                                            '&'],
                                                                 'interps': ['const',
                                                                             '&'],
                                                                 'positions': ['const',
                                                                               '&']},
                                              'types': {'colors': 'MColorArray',
                                                        'interps': 'MIntArray',
                                                        'positions': 'MFloatArray'}}],
                                 'setValueAtIndex': [{'argInfo': {'index': {'doc': 'index of entry to change ',
                                                                            'type': 'uint'},
                                                                  'value': {'doc': 'the new value for the entry ',
                                                                            'type': 'float'}},
                                                      'args': [('value',
                                                                'float',
                                                                'in'),
                                                               ('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the value of a given entry',
                                                      'inArgs': ['value',
                                                                 'index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'index': ['unsigned'],
                                                                         'value': []},
                                                      'types': {'index': 'uint',
                                                                'value': 'float'}}],
                                 'sort': [{'argInfo': {'ascending': {'doc': 'Option for sorting in ascending (default) or descending order.',
                                                                     'type': 'bool'}},
                                           'args': [('ascending',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'ascending': True},
                                           'deprecated': False,
                                           'doc': '\r\nSort the ramp attribute entries by position in ascending or descending order, other arrays are sorted accordingly. Indices are also compressed during the operation.',
                                           'inArgs': ['ascending'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'ascending': []},
                                           'types': {'ascending': 'bool'}}]},
                     'pymelEnums': {'MInterpolation': "Enum('MInterpolation', [('none', 0), ('kNone', 0), ('linear', 1), ('kLinear', 1), ('smooth', 2), ('kSmooth', 2), ('spline', 3), ('kSpline', 3)], multiKeys=True)"}},
  'MRenderCallback': {'enums': {},
                      'methods': {'addCallback': [{'argInfo': {'callback': {'doc': 'object to add to the list of callbacks to invoke ',
                                                                            'type': 'MRenderCallback'},
                                                               'priority': {'doc': 'priority for this callback, lower priorities are invoked first ',
                                                                            'type': 'int'}},
                                                   'args': [('callback',
                                                             'MRenderCallback',
                                                             'in'),
                                                            ('priority',
                                                             'int',
                                                             'in')],
                                                   'defaults': {'priority': 0},
                                                   'deprecated': False,
                                                   'doc': '\r\nStatic procedure to add a rendering callback. The callbacks are stored internally in a sorted list and are invoked following the shadow map generation, software render, or post process depending on which methods are overridden. Adding the same callback more than once will have no effect.',
                                                   'inArgs': ['callback',
                                                              'priority'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'callback': ['*'],
                                                                      'priority': []},
                                                   'types': {'callback': 'MRenderCallback',
                                                             'priority': 'int'}}],
                                  'addRenderTileCallback': [{'argInfo': {'func': {'doc': 'callback function, please check MMessage for more information. ',
                                                                                  'type': ('MMessage',
                                                                                           'MRenderTileFunction')}},
                                                             'args': [('func',
                                                                       ('MMessage',
                                                                        'MRenderTileFunction'),
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nStatic procedure to add a callback to receive tiles as they get rendered and before they get displayed in the Render View Window. The user is provided with the co-ordinates of the origin of the tile, its dimensions, as well as a read only copy of the image being rendered.',
                                                             'inArgs': ['func'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The callback ID of the newly registered callback. ',
                                                                            'qualifiers': [],
                                                                            'type': 'MCallbackId'},
                                                             'returnType': 'MCallbackId',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'func': []},
                                                             'types': {'func': ('MMessage',
                                                                                'MRenderTileFunction')}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'postProcessCallback': [{'argInfo': {'data': {'doc': 'data and functions related to the current frame',
                                                                                'type': 'MRenderData'}},
                                                           'args': [('data',
                                                                     'MRenderData',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nMethod to override for plugging into the post-process. This method will be invoked following the post process rendering (shader glow, optical effects, 2D motion blur). The data argument provides information about the image and camera projection; these are useful in transforming to and from world and image space. If false is returned, the renderer will abort and no image will be generated.',
                                                           'inArgs': ['data'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'True if the operation was successful and false otherwise. ',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {'data': ['const',
                                                                                       '&']},
                                                           'types': {'data': 'MRenderData'}}],
                                  'removeCallback': [{'argInfo': {'callback': {'doc': 'object to remove from the list of callbacks ',
                                                                               'type': 'MRenderCallback'}},
                                                      'args': [('callback',
                                                                'MRenderCallback',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nStatic procedure to remove a rendering callback. The callback will be removed from the list of callbacks, but its up to the client to actually delete the object. Unstability may result if a callback is deleted and not removed from the callback list.Removing an un-installed callback will have no effect.',
                                                      'inArgs': ['callback'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'callback': ['*']},
                                                      'types': {'callback': 'MRenderCallback'}}],
                                  'renderCallback': [{'argInfo': {'data': {'doc': 'data and functions related to the current frame',
                                                                           'type': 'MRenderData'}},
                                                      'args': [('data',
                                                                'MRenderData',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nMethod to override for plugging into image rendering. This method will be invoked following the software render (but before the post process) of each frame. The data argument provides information about the image and camera projection; these are useful in transforming to and from world and image space. If false is returned, the renderer will abort and no image will be generated.',
                                                      'inArgs': ['data'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True if the operation was successful and false otherwise. ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {'data': ['const',
                                                                                  '&']},
                                                      'types': {'data': 'MRenderData'}}],
                                  'shadowCastCallback': [{'argInfo': {'data': {'doc': 'data and functions related to the current shadow map',
                                                                               'type': 'MRenderShadowData'}},
                                                          'args': [('data',
                                                                    'MRenderShadowData',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nMethod to override for plugging into shadow map creation. The argument provides information about the light and shadow map currently being processed. If false is returned, the renderer will abort and no image will be generated.',
                                                          'inArgs': ['data'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'True if the operation was successful and false otherwise. ',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'data': ['const',
                                                                                      '&']},
                                                          'types': {'data': 'MRenderShadowData'}}]},
                      'pymelEnums': {}},
  'MRenderData': {'enums': {},
                  'methods': {'depthArr': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nthis is a 1d array representing the output depth buffer. It is of size: resX * resY, where each depth value is a single precision floating point vlue. It is indexed as [resX * x + y], where (x,y) is the current pixel coordinates. \r\n  Reprocessed example  \n Examples: \n \n   \n renderAccessNode.cpp . \n \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'float*'},
                                            'returnType': 'float*',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'rgbaArr': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nthis is a 1d array representing the output image buffer. It is of size: resX * resY * 4 * bytesPerChannel. The array is indexed as [(resX * x + y) * 4 * bytesPerChannel], where (x,y) is the current pixel coordinates. The "4" multiplier is used for storing RGBA information, in the order of a,b,g,r (on OSX) or b,g,r,a (on Windows and Linux). \r\n  Reprocessed example  \n Examples: \n \n   \n renderAccessNode.cpp . \n \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'char*'},
                                           'returnType': 'char*',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'screenToWorld': [{'argInfo': {'inPoint': {'doc': 'The original point in screen space ',
                                                                         'type': 'MFloatPoint'},
                                                             'outPoint': {'doc': 'The converted point in world space ',
                                                                          'type': 'MFloatPoint'}},
                                                 'args': [('inPoint',
                                                           'MFloatPoint',
                                                           'in'),
                                                          ('outPoint',
                                                           'MFloatPoint',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nConverts screen space point to world space. Screen depth is stored in inPoint.z.',
                                                 'inArgs': ['inPoint'],
                                                 'outArgs': ['outPoint'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'inPoint': ['const',
                                                                                '&'],
                                                                    'outPoint': ['&']},
                                                 'types': {'inPoint': 'MFloatPoint',
                                                           'outPoint': 'MFloatPoint'}}],
                              'worldToScreen': [{'argInfo': {'inPoint': {'doc': 'The original point in world space ',
                                                                         'type': 'MFloatPoint'},
                                                             'outPoint': {'doc': 'The converted point in screen space ',
                                                                          'type': 'MFloatPoint'}},
                                                 'args': [('inPoint',
                                                           'MFloatPoint',
                                                           'in'),
                                                          ('outPoint',
                                                           'MFloatPoint',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nConverts world space point to screen space. Screen depth is stored in outPoint.z.',
                                                 'inArgs': ['inPoint'],
                                                 'outArgs': ['outPoint'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'inPoint': ['const',
                                                                                '&'],
                                                                    'outPoint': ['&']},
                                                 'types': {'inPoint': 'MFloatPoint',
                                                           'outPoint': 'MFloatPoint'}}]},
                  'pymelEnums': {}},
  'MRenderLine': {'enums': {},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'getColor': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the array of colors along the curve.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The color array ',
                                                           'qualifiers': [],
                                                           'type': 'MVectorArray'},
                                            'returnType': 'MVectorArray',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'getFlatness': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the array of flatness along the curve.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The flatness array ',
                                                              'qualifiers': [],
                                                              'type': 'MDoubleArray'},
                                               'returnType': 'MDoubleArray',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'getIncandescence': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nReturn the array of incandescence along the curve.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The incandescence array ',
                                                                   'qualifiers': [],
                                                                   'type': 'MVectorArray'},
                                                    'returnType': 'MVectorArray',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                              'getLine': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturn the array of vertices along the curve.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The vertex array ',
                                                          'qualifiers': [],
                                                          'type': 'MVectorArray'},
                                           'returnType': 'MVectorArray',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'getParameter': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the array of parameter along the curve.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The parameter array ',
                                                               'qualifiers': [],
                                                               'type': 'MDoubleArray'},
                                                'returnType': 'MDoubleArray',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'getTransparency': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the array of transparency along the curve.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The transparency array ',
                                                                  'qualifiers': [],
                                                                  'type': 'MVectorArray'},
                                                   'returnType': 'MVectorArray',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                              'getTwist': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the array of twist vectors along the curve.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The twist vector array ',
                                                           'qualifiers': [],
                                                           'type': 'MVectorArray'},
                                            'returnType': 'MVectorArray',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'getWidth': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturn the array of tube widths along the curve.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The width array ',
                                                           'qualifiers': [],
                                                           'type': 'MDoubleArray'},
                                            'returnType': 'MDoubleArray',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                  'pymelEnums': {}},
  'MRenderLineArray': {'enums': {},
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'deleteArray': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nFree up the memory held in the render line array. This should be called once only and only on one copy of the  MRenderLineArray . (Assignment copies internal pointer data rather than the data its self) \r\n  Reprocessed example  \n Examples: \n \n   \n pfxInfoCmd.cpp . \n \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                   'length': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturn the number of entries in the array.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Array length ',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                   'renderLine': [{'argInfo': {'index': {'doc': 'index of the render line to return ',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturn the render line at the defined index.',
                                                   'inArgs': ['index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The render line',
                                                                  'qualifiers': [],
                                                                  'type': 'MRenderLine'},
                                                   'returnType': 'MRenderLine',
                                                   'static': False,
                                                   'typeQualifiers': {'index': ['unsigned'],
                                                                      'status': ['*']},
                                                   'types': {'index': 'uint'}}]},
                       'pymelEnums': {}},
  'MRenderPassDef': {'enums': {},
                     'methods': {'addDoubleParameter': [{'argInfo': {'UIName': {'doc': 'Name to display in UI for the parameter ',
                                                                                'type': 'MString'},
                                                                     'defaultValue': {'doc': 'The default value of the parameter',
                                                                                      'type': 'double'},
                                                                     'longName': {'doc': 'The full name of the parameter ',
                                                                                  'type': 'MString'},
                                                                     'maxValue': {'doc': 'The maximum value of the parameter ',
                                                                                  'type': 'double'},
                                                                     'minValue': {'doc': 'The minimum value of the parameter ',
                                                                                  'type': 'double'},
                                                                     'shortName': {'doc': 'The short name of the parameter ',
                                                                                   'type': 'MString'}},
                                                         'args': [('longName',
                                                                   'MString',
                                                                   'in'),
                                                                  ('shortName',
                                                                   'MString',
                                                                   'in'),
                                                                  ('UIName',
                                                                   'MString',
                                                                   'in'),
                                                                  ('minValue',
                                                                   'double',
                                                                   'out'),
                                                                  ('maxValue',
                                                                   'double',
                                                                   'out'),
                                                                  ('defaultValue',
                                                                   'double',
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\nDefine a double-precision floating-point parameter for the pass',
                                                         'inArgs': ['longName',
                                                                    'shortName',
                                                                    'UIName'],
                                                         'outArgs': ['minValue',
                                                                     'maxValue',
                                                                     'defaultValue'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'UIName': ['const',
                                                                                       '&'],
                                                                            'defaultValue': ['const',
                                                                                             '&'],
                                                                            'longName': ['const',
                                                                                         '&'],
                                                                            'maxValue': ['const',
                                                                                         '&'],
                                                                            'minValue': ['const',
                                                                                         '&'],
                                                                            'shortName': ['const',
                                                                                          '&']},
                                                         'types': {'UIName': 'MString',
                                                                   'defaultValue': 'double',
                                                                   'longName': 'MString',
                                                                   'maxValue': 'double',
                                                                   'minValue': 'double',
                                                                   'shortName': 'MString'}}],
                                 'addFloatParameter': [{'argInfo': {'UIName': {'doc': 'Name to display in UI for the parameter ',
                                                                               'type': 'MString'},
                                                                    'defaultValue': {'doc': 'The default value of the parameter',
                                                                                     'type': 'float'},
                                                                    'longName': {'doc': 'The full name of the parameter ',
                                                                                 'type': 'MString'},
                                                                    'maxValue': {'doc': 'The maximum value of the parameter ',
                                                                                 'type': 'float'},
                                                                    'minValue': {'doc': 'The minimum value of the parameter ',
                                                                                 'type': 'float'},
                                                                    'shortName': {'doc': 'The short name of the parameter ',
                                                                                  'type': 'MString'}},
                                                        'args': [('longName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('shortName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('UIName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('minValue',
                                                                  'float',
                                                                  'out'),
                                                                 ('maxValue',
                                                                  'float',
                                                                  'out'),
                                                                 ('defaultValue',
                                                                  'float',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nDefine a single-precision floating-point parameter for the pass',
                                                        'inArgs': ['longName',
                                                                   'shortName',
                                                                   'UIName'],
                                                        'outArgs': ['minValue',
                                                                    'maxValue',
                                                                    'defaultValue'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'UIName': ['const',
                                                                                      '&'],
                                                                           'defaultValue': ['const',
                                                                                            '&'],
                                                                           'longName': ['const',
                                                                                        '&'],
                                                                           'maxValue': ['const',
                                                                                        '&'],
                                                                           'minValue': ['const',
                                                                                        '&'],
                                                                           'shortName': ['const',
                                                                                         '&']},
                                                        'types': {'UIName': 'MString',
                                                                  'defaultValue': 'float',
                                                                  'longName': 'MString',
                                                                  'maxValue': 'float',
                                                                  'minValue': 'float',
                                                                  'shortName': 'MString'}}],
                                 'addIntParameter': [{'argInfo': {'UIName': {'doc': 'Name to display in UI for the parameter ',
                                                                             'type': 'MString'},
                                                                  'defaultValue': {'doc': 'The default value of the parameter',
                                                                                   'type': 'int'},
                                                                  'longName': {'doc': 'The full name of the parameter ',
                                                                               'type': 'MString'},
                                                                  'maxValue': {'doc': 'The maximum value of the parameter ',
                                                                               'type': 'int'},
                                                                  'minValue': {'doc': 'The minimum value of the parameter ',
                                                                               'type': 'int'},
                                                                  'shortName': {'doc': 'The short name of the parameter ',
                                                                                'type': 'MString'}},
                                                      'args': [('longName',
                                                                'MString',
                                                                'in'),
                                                               ('shortName',
                                                                'MString',
                                                                'in'),
                                                               ('UIName',
                                                                'MString',
                                                                'in'),
                                                               ('minValue',
                                                                'int',
                                                                'out'),
                                                               ('maxValue',
                                                                'int',
                                                                'out'),
                                                               ('defaultValue',
                                                                'int',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nDefine an integer parameter for the pass',
                                                      'inArgs': ['longName',
                                                                 'shortName',
                                                                 'UIName'],
                                                      'outArgs': ['minValue',
                                                                  'maxValue',
                                                                  'defaultValue'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'UIName': ['const',
                                                                                    '&'],
                                                                         'defaultValue': ['const',
                                                                                          '&'],
                                                                         'longName': ['const',
                                                                                      '&'],
                                                                         'maxValue': ['const',
                                                                                      '&'],
                                                                         'minValue': ['const',
                                                                                      '&'],
                                                                         'shortName': ['const',
                                                                                       '&']},
                                                      'types': {'UIName': 'MString',
                                                                'defaultValue': 'int',
                                                                'longName': 'MString',
                                                                'maxValue': 'int',
                                                                'minValue': 'int',
                                                                'shortName': 'MString'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'getAttributeType': [{'argInfo': {'attributeName': {'doc': 'The name of the render pass attribute to query. ',
                                                                                     'type': 'MString'}},
                                                       'args': [('attributeName',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nRetrieve the type of a given render pass attribute',
                                                       'inArgs': ['attributeName'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The type of the given attribute.',
                                                                      'qualifiers': [],
                                                                      'type': 'MString'},
                                                       'returnType': 'MString',
                                                       'static': False,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'attributeName': ['const',
                                                                                            '&']},
                                                       'types': {'attributeName': 'MString'}}],
                                 'getDescription': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nRetrieve the description for this pass',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The description',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': False,
                                                     'typeQualifiers': {'ReturnStatus': ['*']},
                                                     'types': {}}],
                                 'getGroup': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nRetrieve the pass group for this pass',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The pass group',
                                                              'qualifiers': [],
                                                              'type': 'MString'},
                                               'returnType': 'MString',
                                               'static': False,
                                               'typeQualifiers': {'ReturnStatus': ['*']},
                                               'types': {}}],
                                 'getID': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nRetrieve the pass ID for this pass.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The pass ID',
                                                           'qualifiers': [],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {'ReturnStatus': ['*']},
                                            'types': {}}],
                                 'getImplementation': [{'argInfo': {'fbType': {'doc': 'The base data type of the frame buffer ',
                                                                               'type': ('MPxRenderPassImpl',
                                                                                        'PassTypeBit')},
                                                                    'numChannels': {'doc': 'The number of components per pixel in the frame buffer ',
                                                                                    'type': 'uint'},
                                                                    'renderer': {'doc': 'The renderer ',
                                                                                 'type': 'MString'}},
                                                        'args': [('renderer',
                                                                  'MString',
                                                                  'in'),
                                                                 ('fbType',
                                                                  ('MPxRenderPassImpl',
                                                                   'PassTypeBit'),
                                                                  'in'),
                                                                 ('numChannels',
                                                                  'uint',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieve an implementation of this render pass for the given renderer. That supports the specified data type and the specified number of channels.',
                                                        'inArgs': ['renderer',
                                                                   'fbType',
                                                                   'numChannels'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'A pointer to the pass implementation or null if no definition exists',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'MPxRenderPassImpl'},
                                                        'returnType': 'MPxRenderPassImpl',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'fbType': [],
                                                                           'numChannels': ['unsigned'],
                                                                           'renderer': ['const',
                                                                                        '&']},
                                                        'types': {'fbType': ('MPxRenderPassImpl',
                                                                             'PassTypeBit'),
                                                                  'numChannels': 'uint',
                                                                  'renderer': 'MString'}},
                                                       {'argInfo': {'renderer': {'doc': 'The renderer ',
                                                                                 'type': 'MString'}},
                                                        'args': [('renderer',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nRetrieve an implementation of this render pass for the given renderer.',
                                                        'inArgs': ['renderer'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'A pointer to the pass implementation or null if no definition exists',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'MPxRenderPassImpl'},
                                                        'returnType': 'MPxRenderPassImpl',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'renderer': ['const',
                                                                                        '&']},
                                                        'types': {'renderer': 'MString'}}],
                                 'getName': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nRetrieve the pass name for this pass',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The pass name',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}]},
                     'pymelEnums': {}},
  'MRenderPassRegistry': {'enums': {},
                          'methods': {'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nReturns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'getRenderPassDefinition': [{'argInfo': {'passID': {'doc': 'The ID of the pass ',
                                                                                          'type': 'MString'}},
                                                                   'args': [('passID',
                                                                             'MString',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nRetrieve the definition of the specified render pass',
                                                                   'inArgs': ['passID'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'The render pass definition if successful',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MRenderPassDef'},
                                                                   'returnType': 'MRenderPassDef',
                                                                   'static': True,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'passID': ['const',
                                                                                                 '&']},
                                                                   'types': {'passID': 'MString'}}],
                                      'registerRenderPassDefinition': [{'argInfo': {'description': {'doc': 'A description of the new pass ',
                                                                                                    'type': 'MString'},
                                                                                    'overload': {'doc': 'If true, override any existing pass with the same passID with this pass definiton ',
                                                                                                 'type': 'bool'},
                                                                                    'passGroup': {'doc': 'The classification of the new pass ',
                                                                                                  'type': 'MString'},
                                                                                    'passID': {'doc': 'The ID of the pass ',
                                                                                               'type': 'MString'},
                                                                                    'passName': {'doc': 'The name of the new pass ',
                                                                                                 'type': 'MString'}},
                                                                        'args': [('passID',
                                                                                  'MString',
                                                                                  'in'),
                                                                                 ('passName',
                                                                                  'MString',
                                                                                  'in'),
                                                                                 ('passGroup',
                                                                                  'MString',
                                                                                  'in'),
                                                                                 ('description',
                                                                                  'MString',
                                                                                  'in'),
                                                                                 ('overload',
                                                                                  'bool',
                                                                                  'in')],
                                                                        'defaults': {'overload': False},
                                                                        'deprecated': False,
                                                                        'doc': '\nCreates a new render pass definition and registers it with the internal render pass registry. Returns the definition.',
                                                                        'inArgs': ['passID',
                                                                                   'passName',
                                                                                   'passGroup',
                                                                                   'description',
                                                                                   'overload'],
                                                                        'outArgs': [],
                                                                        'returnInfo': {'doc': 'The render pass definition if successful',
                                                                                       'qualifiers': [],
                                                                                       'type': 'MRenderPassDef'},
                                                                        'returnType': 'MRenderPassDef',
                                                                        'static': True,
                                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                           'description': ['const',
                                                                                                           '&'],
                                                                                           'overload': [],
                                                                                           'passGroup': ['const',
                                                                                                         '&'],
                                                                                           'passID': ['const',
                                                                                                      '&'],
                                                                                           'passName': ['const',
                                                                                                        '&']},
                                                                        'types': {'description': 'MString',
                                                                                  'overload': 'bool',
                                                                                  'passGroup': 'MString',
                                                                                  'passID': 'MString',
                                                                                  'passName': 'MString'}}]},
                          'pymelEnums': {}},
  'MRenderProfile': {'enums': {'MStandardRenderer': {'valueDocs': {'D3D': '',
                                                                   'kMayaD3D': '',
                                                                   'kMayaOpenGL': '',
                                                                   'kMayaSoftware': '',
                                                                   'openGL': '',
                                                                   'software': ''},
                                                     'values': "Enum('MStandardRenderer', {'kMayaSoftware': 0, 'kMayaOpenGL': 1, 'kMayaD3D': 2})"}},
                     'methods': {'addRenderer': [{'argInfo': {'renderer': {'doc': 'The internal Maya renderer to add to this profile. ',
                                                                           'type': ('MRenderProfile',
                                                                                    'MStandardRenderer')}},
                                                  'args': [('renderer',
                                                            ('MRenderProfile',
                                                             'MStandardRenderer'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nAdd one of Maya's internal renderers to this render profile.",
                                                  'inArgs': ['renderer'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'renderer': []},
                                                  'types': {'renderer': ('MRenderProfile',
                                                                         'MStandardRenderer')}},
                                                 {'argInfo': {'name': {'doc': 'The name of the renderer. ',
                                                                       'type': 'MString'},
                                                              'version': {'doc': 'The version of the renderer or rendering API. ',
                                                                          'type': 'float'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in'),
                                                           ('version',
                                                            'float',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nAdd a custom entry to this render profile. The name and version specified must correspond to a renderer registered with Maya. Currently, only Maya\'s internal renderers (just named after the APIs they use: "OpenGL", "D3D", or "Software") are supported. When registering support for Maya\'s internal renderers, it\'s simpler to use the other version of this method.',
                                                  'inArgs': ['name',
                                                             'version'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'name': ['const',
                                                                              '&'],
                                                                     'version': []},
                                                  'types': {'name': 'MString',
                                                            'version': 'float'}}],
                                 'hasRenderer': [{'argInfo': {'renderer': {'doc': 'The internal Maya renderer to search for ',
                                                                           'type': ('MRenderProfile',
                                                                                    'MStandardRenderer')}},
                                                  'args': [('renderer',
                                                            ('MRenderProfile',
                                                             'MStandardRenderer'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSee if a Maya renderer is listed in this profile.',
                                                  'inArgs': ['renderer'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'renderer': []},
                                                  'types': {'renderer': ('MRenderProfile',
                                                                         'MStandardRenderer')}},
                                                 {'argInfo': {'name': {'doc': 'The name of the renderer. ',
                                                                       'type': 'MString'},
                                                              'version': {'doc': 'The version of the renderer or rendering API. ',
                                                                          'type': 'float'}},
                                                  'args': [('name',
                                                            'MString',
                                                            'in'),
                                                           ('version',
                                                            'float',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nFind a custom entry in this render profile.',
                                                  'inArgs': ['name',
                                                             'version'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'name': ['const',
                                                                              '&'],
                                                                     'version': []},
                                                  'types': {'name': 'MString',
                                                            'version': 'float'}}],
                                 'numberOfRenderers': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nFind the number of renderers in this profile.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}]},
                     'pymelEnums': {'MStandardRenderer': "Enum('MStandardRenderer', [('software', 0), ('kMayaSoftware', 0), ('openGL', 1), ('kMayaOpenGL', 1), ('D3D', 2), ('kMayaD3D', 2)], multiKeys=True)"}},
  'MRenderSetup': {'enums': {},
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'getEnabledSelectedNodeNames': [{'argInfo': {'renderLayerName': {'doc': 'Name of the render setup render layer. ',
                                                                                                'type': 'MString'}},
                                                                'args': [('renderLayerName',
                                                                          'MString',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nReturn the members of a render setup render layer. \n',
                                                                'inArgs': ['renderLayerName'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Array of members of the render setup render layer.',
                                                                               'qualifiers': [],
                                                                               'type': 'MStringArray'},
                                                                'returnType': 'MStringArray',
                                                                'static': True,
                                                                'typeQualifiers': {'renderLayerName': ['const',
                                                                                                       '&'],
                                                                                   'status': ['*']},
                                                                'types': {'renderLayerName': 'MString'}}]},
                   'pymelEnums': {}},
  'MRenderShadowData': {'enums': {'LightType': {'valueDocs': {'directional': '',
                                                              'invalid': '',
                                                              'kDirectional': '',
                                                              'kInvalid': '',
                                                              'kPoint': '',
                                                              'kSpot': '',
                                                              'point': '',
                                                              'spot': ''},
                                                'values': "Enum('LightType', {'kInvalid': 0, 'kPoint': 1, 'kDirectional': 2, 'kSpot': 3})"}},
                        'methods': {'worldToZbuffer': [{'argInfo': {'inPoint': {'doc': 'The original point in world space ',
                                                                                'type': 'MFloatPoint'},
                                                                    'outPoint': {'doc': 'The converted point in shadow map ',
                                                                                 'type': 'MFloatPoint'}},
                                                        'args': [('inPoint',
                                                                  'MFloatPoint',
                                                                  'in'),
                                                                 ('outPoint',
                                                                  'MFloatPoint',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nConverts world space point to shadow map. Shadow depth is stored in inPoint.z',
                                                        'inArgs': ['inPoint'],
                                                        'outArgs': ['outPoint'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'inPoint': ['const',
                                                                                       '&'],
                                                                           'outPoint': ['&']},
                                                        'types': {'inPoint': 'MFloatPoint',
                                                                  'outPoint': 'MFloatPoint'}}],
                                    'zbufferToWorld': [{'argInfo': {'inPoint': {'doc': 'The original point in shadow map ',
                                                                                'type': 'MFloatPoint'},
                                                                    'outPoint': {'doc': 'The converted point in world space ',
                                                                                 'type': 'MFloatPoint'}},
                                                        'args': [('inPoint',
                                                                  'MFloatPoint',
                                                                  'in'),
                                                                 ('outPoint',
                                                                  'MFloatPoint',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nConverts shadow map point to world space. Shadow depth is stored in inPoint.z.',
                                                        'inArgs': ['inPoint'],
                                                        'outArgs': ['outPoint'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'inPoint': ['const',
                                                                                       '&'],
                                                                           'outPoint': ['&']},
                                                        'types': {'inPoint': 'MFloatPoint',
                                                                  'outPoint': 'MFloatPoint'}}]},
                        'pymelEnums': {'LightType': "Enum('LightType', [('invalid', 0), ('kInvalid', 0), ('point', 1), ('kPoint', 1), ('directional', 2), ('kDirectional', 2), ('spot', 3), ('kSpot', 3)], multiKeys=True)"}},
  'MRenderTargetLegacy': {'enums': {},
                          'methods': {'height': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nHeight of render target in pixels. \r\n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Height value. ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                      'makeTargetCurrent': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nMake the render target current for rendering. \r\n',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                      'width': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nWidth of render target in pixels. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Width value. ',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                      'writeColorBuffer': [{'argInfo': {'image': {'doc': 'an MImage 2d image ',
                                                                                  'type': 'MImage'},
                                                                        'writeDepth': {'doc': 'write the depth component of the incoming image to the depth component of the render target. If image does not contain any depth component then nothing will be written. Default value is false.',
                                                                                       'type': 'bool'},
                                                                        'x': {'doc': 'lower left corner x position in the target to place the image. Default value is 0. ',
                                                                              'type': 'signed'},
                                                                        'y': {'doc': 'lower left corner y position in the target to place the image Default value is 0. ',
                                                                              'type': 'signed'}},
                                                            'args': [('image',
                                                                      'MImage',
                                                                      'in'),
                                                                     ('x',
                                                                      'signed',
                                                                      'in'),
                                                                     ('y',
                                                                      'signed',
                                                                      'in'),
                                                                     ('writeDepth',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {'writeDepth': False,
                                                                         'x': '0',
                                                                         'y': '0'},
                                                            'deprecated': False,
                                                            'doc': '\r\nWrite a 2d image directly to the color buffer, without any transformation. Method will make the context current if it is not already.',
                                                            'inArgs': ['image',
                                                                       'x',
                                                                       'y',
                                                                       'writeDepth'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'image': ['const',
                                                                                         '&'],
                                                                               'writeDepth': [],
                                                                               'x': ['short'],
                                                                               'y': ['short']},
                                                            'types': {'image': 'MImage',
                                                                      'writeDepth': 'bool',
                                                                      'x': 'signed',
                                                                      'y': 'signed'}}]},
                          'pymelEnums': {}},
  'MRenderUtil': {'enums': {'MRenderPass': {'valueDocs': {'all': 'Default case, compute everything.',
                                                          'ambientOnly': 'Compute only ambient information.',
                                                          'colorOnly': 'Compute only color information, no shadows.',
                                                          'diffuseOnly': 'Compute only diffuse information.',
                                                          'kAll': 'Default case, compute everything.',
                                                          'kAmbientOnly': 'Compute only ambient information.',
                                                          'kColorOnly': 'Compute only color information, no shadows.',
                                                          'kDiffuseOnly': 'Compute only diffuse information.',
                                                          'kShadowOnly': 'Compute only shadow information, no color.',
                                                          'kSpecularOnly': 'Compute only specular information.',
                                                          'shadowOnly': 'Compute only shadow information, no color.',
                                                          'specularOnly': 'Compute only specular information.'},
                                            'values': "Enum('MRenderPass', {'kAll': 0, 'kColorOnly': 1, 'kShadowOnly': 2, 'kAmbientOnly': 3, 'kDiffuseOnly': 4, 'kSpecularOnly': 5})"},
                            'MRenderState': {'valueDocs': {'batchRender': 'Performing a batch render.',
                                                           'hardwareRender': 'Performing a hardware render.',
                                                           'interactiveRender': 'Performing an interactive render.',
                                                           'iprRender': 'Performing an IPR render.',
                                                           'kBatchRender': 'Performing a batch render.',
                                                           'kHardwareRender': 'Performing a hardware render.',
                                                           'kInteractiveRender': 'Performing an interactive render.',
                                                           'kIprRender': 'Performing an IPR render.',
                                                           'kNotRendering': 'Not rendering.',
                                                           'notRendering': 'Not rendering.'},
                                             'values': "Enum('MRenderState', {'kNotRendering': 0, 'kBatchRender': 1, 'kInteractiveRender': 2, 'kIprRender': 3, 'kHardwareRender': 4})"}},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'convertPsdFile': [{'argInfo': {'fileNode': {'doc': 'a file texture node ',
                                                                           'type': 'MObject'},
                                                              'forExport': {'doc': 'if true the resulting IFF file will be stored in the project directory tree, otherwise it will be stored in a temporary file which will be deleted when Maya exits. ',
                                                                            'type': 'bool'},
                                                              'texturePath': {'doc': 'returns an absolute pathname to the texture file referenced by the node. ',
                                                                              'type': 'MString'}},
                                                  'args': [('fileNode',
                                                            'MObject',
                                                            'in'),
                                                           ('texturePath',
                                                            'MString',
                                                            'out'),
                                                           ('forExport',
                                                            'bool',
                                                            'out')],
                                                  'defaults': {'forExport': False},
                                                  'deprecated': False,
                                                  'doc': '\r\nInternal use only. \r\n',
                                                  'inArgs': ['fileNode'],
                                                  'outArgs': ['texturePath',
                                                              'forExport'],
                                                  'returnInfo': {'doc': ' true if the image file pathname was successfully resolved and exporting psd file is succeeded.  false if the pathname could not be resolved or exporting psd file fails.  ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'fileNode': ['const',
                                                                                  '&'],
                                                                     'forExport': ['const',
                                                                                   '&'],
                                                                     'texturePath': ['&']},
                                                  'types': {'fileNode': 'MObject',
                                                            'forExport': 'bool',
                                                            'texturePath': 'MString'}},
                                                 {'argInfo': {'fileNode': {'doc': 'a file texture node ',
                                                                           'type': 'MObject'},
                                                              'forExport': {'doc': 'if true the resulting IFF file will be stored in the project directory tree, otherwise it will be stored in a temporary file which will be deleted when Maya exits. ',
                                                                            'type': 'bool'}},
                                                  'args': [('fileNode',
                                                            'MObject',
                                                            'in'),
                                                           ('forExport',
                                                            'bool',
                                                            'out')],
                                                  'defaults': {'forExport': False},
                                                  'deprecated': False,
                                                  'doc': '\r\nInternal use only. \r\n',
                                                  'inArgs': ['fileNode'],
                                                  'outArgs': ['forExport'],
                                                  'returnInfo': {'doc': ' true if the image file pathname was successfully resolved and exporting psd file is succeeded.  false if the pathname could not be resolved or exporting psd file fails.  ',
                                                                 'qualifiers': [],
                                                                 'type': 'MString'},
                                                  'returnType': 'MString',
                                                  'static': True,
                                                  'typeQualifiers': {'ReturnStatus': ['*'],
                                                                     'fileNode': ['const',
                                                                                  '&'],
                                                                     'forExport': ['const',
                                                                                   '&']},
                                                  'types': {'fileNode': 'MObject',
                                                            'forExport': 'bool'}}],
                              'diffuseReflectance': [{'argInfo': {'lightBackFace': {'doc': 'Is the back face being lit, true or false. ',
                                                                                    'type': 'bool'},
                                                                  'lightBlindData': {'doc': 'The reference to the aLightBlindData attribute of the current light being evaluated ',
                                                                                     'type': 'void'},
                                                                  'lightDirection': {'doc': 'The direction of the light being evaluated ',
                                                                                     'type': 'MFloatVector'},
                                                                  'normal': {'doc': 'The surface normal ',
                                                                             'type': 'MFloatVector'},
                                                                  'pointCamera': {'doc': 'The position of the camera ',
                                                                                  'type': 'MFloatVector'}},
                                                      'args': [('lightBlindData',
                                                                'void',
                                                                'in'),
                                                               ('lightDirection',
                                                                'MFloatVector',
                                                                'in'),
                                                               ('pointCamera',
                                                                'MFloatVector',
                                                                'in'),
                                                               ('normal',
                                                                'MFloatVector',
                                                                'in'),
                                                               ('lightBackFace',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis utility function computes and returns the diffuse or lambertian reflectance for a given light source and surface.',
                                                      'inArgs': ['lightBlindData',
                                                                 'lightDirection',
                                                                 'pointCamera',
                                                                 'normal',
                                                                 'lightBackFace'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'lightBackFace': [],
                                                                         'lightBlindData': ['const',
                                                                                            '*'],
                                                                         'lightDirection': ['const',
                                                                                            '&'],
                                                                         'normal': ['const',
                                                                                    '&'],
                                                                         'pointCamera': ['const',
                                                                                         '&']},
                                                      'types': {'lightBackFace': 'bool',
                                                                'lightBlindData': 'void',
                                                                'lightDirection': 'MFloatVector',
                                                                'normal': 'MFloatVector',
                                                                'pointCamera': 'MFloatVector'}}],
                              'eval2dTexture': [{'argInfo': {'resultAlphas': {'doc': 'if non-NULL, receives the outAlpha values evaluated from the texture at these same points.',
                                                                              'type': 'MDoubleArray'},
                                                             'resultColors': {'doc': "if non-NULL, receives the result of the connected texture's outColor attribute, evaluated at all the (u,v) coordinates given by the uCoords and vCoords arrays. ",
                                                                              'type': 'MVectorArray'},
                                                             'texNode': {'doc': "texture node to evaluate. It doesn't need to be connected to anything. ",
                                                                         'type': 'MObject'},
                                                             'uCoords': {'doc': 'array of u coordinate values ',
                                                                         'type': 'MDoubleArray'},
                                                             'vCoords': {'doc': 'array of v coordinate values ',
                                                                         'type': 'MDoubleArray'}},
                                                 'args': [('texNode',
                                                           'MObject',
                                                           'in'),
                                                          ('uCoords',
                                                           'MDoubleArray',
                                                           'in'),
                                                          ('vCoords',
                                                           'MDoubleArray',
                                                           'in'),
                                                          ('resultColors',
                                                           'MVectorArray',
                                                           'out'),
                                                          ('resultAlphas',
                                                           'MDoubleArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nIf a supported texture node is given, this method can be called to evaluate that texture at a number of (u,v) texture coordinate values.',
                                                 'inArgs': ['texNode',
                                                            'uCoords',
                                                            'vCoords'],
                                                 'outArgs': ['resultColors',
                                                             'resultAlphas'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {'resultAlphas': ['*'],
                                                                    'resultColors': ['*'],
                                                                    'texNode': ['const',
                                                                                '&'],
                                                                    'uCoords': ['&'],
                                                                    'vCoords': ['&']},
                                                 'types': {'resultAlphas': 'MDoubleArray',
                                                           'resultColors': 'MVectorArray',
                                                           'texNode': 'MObject',
                                                           'uCoords': 'MDoubleArray',
                                                           'vCoords': 'MDoubleArray'}}],
                              'exactFileTextureName': [{'argInfo': {'fileNode': {'doc': 'a file texture node ',
                                                                                 'type': 'MObject'},
                                                                    'texturePath': {'doc': 'returns an absolute pathname to the texture file referenced by the node. ',
                                                                                    'type': 'MString'}},
                                                        'args': [('fileNode',
                                                                  'MObject',
                                                                  'in'),
                                                                 ('texturePath',
                                                                  'MString',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nAttempts to resolve the file texture name specified on a file texture node into an absolute path to an image file on disk. The function applies exactly the same logic that is used by the file texture node internally for resolving the image file path.',
                                                        'inArgs': ['fileNode'],
                                                        'outArgs': ['texturePath'],
                                                        'returnInfo': {'doc': 'true if the image file pathname was successfully resolved, false otherwise.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'fileNode': ['const',
                                                                                        '&'],
                                                                           'texturePath': ['&']},
                                                        'types': {'fileNode': 'MObject',
                                                                  'texturePath': 'MString'}},
                                                       {'argInfo': {'baseName': {'doc': 'a file name to be resolved ',
                                                                                 'type': 'MString'},
                                                                    'currentFrameExt': {'doc': 'specify a frame extension if useFrameExt is used. ',
                                                                                        'type': 'MString'},
                                                                    'exactName': {'doc': 'resolved file name with absolute path ',
                                                                                  'type': 'MString'},
                                                                    'useFrameExt': {'doc': 'use frame extension for image file name ',
                                                                                    'type': 'bool'}},
                                                        'args': [('baseName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('useFrameExt',
                                                                  'bool',
                                                                  'in'),
                                                                 ('currentFrameExt',
                                                                  'MString',
                                                                  'in'),
                                                                 ('exactName',
                                                                  'MString',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': True,
                                                        'doc': '\r\nobsolete, use the one with contextNodeFullName param \r\n',
                                                        'inArgs': ['baseName',
                                                                   'useFrameExt',
                                                                   'currentFrameExt'],
                                                        'outArgs': ['exactName'],
                                                        'returnInfo': {'doc': ' true if the file pathname was successfully resolved.  false if the pathname could not be resolved.  ',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'baseName': ['const',
                                                                                        '&'],
                                                                           'currentFrameExt': ['const',
                                                                                               '&'],
                                                                           'exactName': ['&'],
                                                                           'useFrameExt': []},
                                                        'types': {'baseName': 'MString',
                                                                  'currentFrameExt': 'MString',
                                                                  'exactName': 'MString',
                                                                  'useFrameExt': 'bool'}},
                                                       {'argInfo': {'baseName': {'doc': 'a file name to be resolved ',
                                                                                 'type': 'MString'},
                                                                    'contextNodeFullName': {'doc': 'full name of the file owner Node. ',
                                                                                            'type': 'MString'},
                                                                    'currentFrameExt': {'doc': 'specify a frame extension if useFrameExt is used. ',
                                                                                        'type': 'MString'},
                                                                    'exactName': {'doc': 'resolved file name with absolute path ',
                                                                                  'type': 'MString'},
                                                                    'useFrameExt': {'doc': 'use frame extension for image file name ',
                                                                                    'type': 'bool'}},
                                                        'args': [('baseName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('useFrameExt',
                                                                  'bool',
                                                                  'in'),
                                                                 ('currentFrameExt',
                                                                  'MString',
                                                                  'in'),
                                                                 ('contextNodeFullName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('exactName',
                                                                  'MString',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nAttempts to resolve the file name specified into an absolute path to a file on disk. The function applies exactly the same logic that is used by the file texture node internally for resolving the image file path.',
                                                        'inArgs': ['baseName',
                                                                   'useFrameExt',
                                                                   'currentFrameExt',
                                                                   'contextNodeFullName'],
                                                        'outArgs': ['exactName'],
                                                        'returnInfo': {'doc': ' true if the file pathname was successfully resolved.  false if the pathname could not be resolved.  ',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'baseName': ['const',
                                                                                        '&'],
                                                                           'contextNodeFullName': ['const',
                                                                                                   '&'],
                                                                           'currentFrameExt': ['const',
                                                                                               '&'],
                                                                           'exactName': ['&'],
                                                                           'useFrameExt': []},
                                                        'types': {'baseName': 'MString',
                                                                  'contextNodeFullName': 'MString',
                                                                  'currentFrameExt': 'MString',
                                                                  'exactName': 'MString',
                                                                  'useFrameExt': 'bool'}},
                                                       {'argInfo': {'fileNode': {'doc': 'a file texture node ',
                                                                                 'type': 'MObject'}},
                                                        'args': [('fileNode',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nAttempts to resolve the file texture name specified on a file texture node into an absolute path to an image file on disk. The function applies exactly the same logic that is used by the file texture node internally for resolving the image file path.',
                                                        'inArgs': ['fileNode'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'An absolute pathname to the texture file referenced by the node. If the path cannot be resolved than an empty string is returned',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'fileNode': ['const',
                                                                                        '&']},
                                                        'types': {'fileNode': 'MObject'}},
                                                       {'argInfo': {'baseName': {'doc': 'a file name to be resolved ',
                                                                                 'type': 'MString'},
                                                                    'currentFrameExt': {'doc': 'specify a frame extension if useFrameExt is used. ',
                                                                                        'type': 'MString'},
                                                                    'useFrameExt': {'doc': 'use frame extension for image file name ',
                                                                                    'type': 'bool'}},
                                                        'args': [('baseName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('useFrameExt',
                                                                  'bool',
                                                                  'in'),
                                                                 ('currentFrameExt',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': True,
                                                        'doc': '\r\nobsolete, use the one with contextNodeFullName param \r\n',
                                                        'inArgs': ['baseName',
                                                                   'useFrameExt',
                                                                   'currentFrameExt'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'An absolute path to the texture based on its file name. If the path cannot be resolved, then an empty string is returned.',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'baseName': ['const',
                                                                                        '&'],
                                                                           'currentFrameExt': ['const',
                                                                                               '&'],
                                                                           'useFrameExt': []},
                                                        'types': {'baseName': 'MString',
                                                                  'currentFrameExt': 'MString',
                                                                  'useFrameExt': 'bool'}},
                                                       {'argInfo': {'baseName': {'doc': 'a file name to be resolved ',
                                                                                 'type': 'MString'},
                                                                    'contextNodeFullName': {'doc': 'full name of the file owner Node. ',
                                                                                            'type': 'MString'},
                                                                    'currentFrameExt': {'doc': 'specify a frame extension if useFrameExt is used. ',
                                                                                        'type': 'MString'},
                                                                    'useFrameExt': {'doc': 'use frame extension for image file name ',
                                                                                    'type': 'bool'}},
                                                        'args': [('baseName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('useFrameExt',
                                                                  'bool',
                                                                  'in'),
                                                                 ('currentFrameExt',
                                                                  'MString',
                                                                  'in'),
                                                                 ('contextNodeFullName',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nAttempts to resolve the file name specified into an absolute path to a file on disk. The function applies exactly the same logic that is used by the file texture node internally for resolving the image file path.',
                                                        'inArgs': ['baseName',
                                                                   'useFrameExt',
                                                                   'currentFrameExt',
                                                                   'contextNodeFullName'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'An absolute path to the texture based on its file name. If the path cannot be resolved, then an empty string is returned.',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'baseName': ['const',
                                                                                        '&'],
                                                                           'contextNodeFullName': ['const',
                                                                                                   '&'],
                                                                           'currentFrameExt': ['const',
                                                                                               '&'],
                                                                           'useFrameExt': []},
                                                        'types': {'baseName': 'MString',
                                                                  'contextNodeFullName': 'MString',
                                                                  'currentFrameExt': 'MString',
                                                                  'useFrameExt': 'bool'}}],
                              'exactFileTextureUvTileData': [{'argInfo': {'fileNode': {'doc': 'A file texture node ',
                                                                                       'type': 'MObject'},
                                                                          'tilePaths': {'doc': 'Returns the set of absolute pathnames to the UV tiles for the given texture texture file node ',
                                                                                        'type': 'MStringArray'},
                                                                          'tilePositions': {'doc': 'Returns the lower left coordinate of each tile in UV space. ',
                                                                                            'type': 'MFloatArray'}},
                                                              'args': [('fileNode',
                                                                        'MObject',
                                                                        'in'),
                                                                       ('tilePaths',
                                                                        'MStringArray',
                                                                        'out'),
                                                                       ('tilePositions',
                                                                        'MFloatArray',
                                                                        'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': "\r\nAttempts to resolve all the paths to UV tiles for the given file texture node into absolute paths to image files on disk. Also computes the lower left coordinate of each tile in UV space. The coordinates are returned in a flat array of floats so for tile 'n', the coordinate is given by: (tilePositions[n*2], tilePositions[n*2+1]).",
                                                              'inArgs': ['fileNode'],
                                                              'outArgs': ['tilePaths',
                                                                          'tilePositions'],
                                                              'returnInfo': {'doc': 'True if at least one tile was resolved, false otherwise.',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'fileNode': ['const',
                                                                                              '&'],
                                                                                 'tilePaths': ['&'],
                                                                                 'tilePositions': ['&']},
                                                              'types': {'fileNode': 'MObject',
                                                                        'tilePaths': 'MStringArray',
                                                                        'tilePositions': 'MFloatArray'}}],
                              'exactImagePlaneFileName': [{'argInfo': {'imagePlaneNode': {'doc': 'an image plane node ',
                                                                                          'type': 'MObject'},
                                                                       'texturePath': {'doc': 'returns an absolute pathname to the texture file referenced by the node. ',
                                                                                       'type': 'MString'}},
                                                           'args': [('imagePlaneNode',
                                                                     'MObject',
                                                                     'in'),
                                                                    ('texturePath',
                                                                     'MString',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nAttempts to resolve the file texture name specified on an image plane node into an absolute path to an image file on disk. The function applies exactly the same logic that is used by the image plane node internally for resolving the image file path.',
                                                           'inArgs': ['imagePlaneNode'],
                                                           'outArgs': ['texturePath'],
                                                           'returnInfo': {'doc': ' true if the image file pathname was successfully resolved.  false if the pathname could not be resolved.  ',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'imagePlaneNode': ['const',
                                                                                                 '&'],
                                                                              'texturePath': ['&']},
                                                           'types': {'imagePlaneNode': 'MObject',
                                                                     'texturePath': 'MString'}},
                                                          {'argInfo': {'imagePlaneNode': {'doc': 'an image plane node ',
                                                                                          'type': 'MObject'}},
                                                           'args': [('imagePlaneNode',
                                                                     'MObject',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nAttempts to resolve the file texture name specified on an image plane node into an absolute path to an image file on disk. The function applies exactly the same logic that is used by the image plane node internally for resolving the image file path.',
                                                           'inArgs': ['imagePlaneNode'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'An absolute pathname to the texture file referenced by the node. If the pathname cannot be resolved, then the returned string is empty',
                                                                          'qualifiers': [],
                                                                          'type': 'MString'},
                                                           'returnType': 'MString',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'imagePlaneNode': ['const',
                                                                                                 '&']},
                                                           'types': {'imagePlaneNode': 'MObject'}}],
                              'generatingIprFile': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nReturns true if an IPR file is being created. This can be used to optimize the IPR file. Lights do not need to request particle information (IPR does not support particle rendering) when creating a IPR file.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                              'getCommonRenderSettings': [{'argInfo': {'mrgData': {'doc': 'Render settings. ',
                                                                                   'type': 'MCommonRenderSettingsData'}},
                                                           'args': [('mrgData',
                                                                     'MCommonRenderSettingsData',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nFill the set of common render setting values',
                                                           'inArgs': [],
                                                           'outArgs': ['mrgData'],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': True,
                                                           'typeQualifiers': {'mrgData': ['&']},
                                                           'types': {'mrgData': 'MCommonRenderSettingsData'}}],
                              'hemisphereCoverage': [{'argInfo': {'lightBackFace': {'doc': 'Is the back face being lit, true or false. ',
                                                                                    'type': 'bool'},
                                                                  'lightBlindData': {'doc': 'The reference to the aLightBlindData attribute of the current light being evaluated ',
                                                                                     'type': 'void'},
                                                                  'lightDirection': {'doc': 'The direction of the light being evaluated ',
                                                                                     'type': 'MFloatVector'},
                                                                  'pointCamera': {'doc': 'The position of the camera ',
                                                                                  'type': 'MFloatVector'},
                                                                  'rayDirection': {'doc': 'The direction of the current intersection ray in camera space ',
                                                                                   'type': 'MFloatVector'}},
                                                      'args': [('lightBlindData',
                                                                'void',
                                                                'in'),
                                                               ('lightDirection',
                                                                'MFloatVector',
                                                                'in'),
                                                               ('pointCamera',
                                                                'MFloatVector',
                                                                'in'),
                                                               ('rayDirection',
                                                                'MFloatVector',
                                                                'in'),
                                                               ('lightBackFace',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nThis utility function computes and returns the fraction of the light that is transmitted by an object. It is mostly used for translucence and scattering effects.',
                                                      'inArgs': ['lightBlindData',
                                                                 'lightDirection',
                                                                 'pointCamera',
                                                                 'rayDirection',
                                                                 'lightBackFace'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'lightBackFace': [],
                                                                         'lightBlindData': ['const',
                                                                                            '*'],
                                                                         'lightDirection': ['const',
                                                                                            '&'],
                                                                         'pointCamera': ['const',
                                                                                         '&'],
                                                                         'rayDirection': ['const',
                                                                                          '&']},
                                                      'types': {'lightBackFace': 'bool',
                                                                'lightBlindData': 'void',
                                                                'lightDirection': 'MFloatVector',
                                                                'pointCamera': 'MFloatVector',
                                                                'rayDirection': 'MFloatVector'}}],
                              'inCurrentRenderLayer': [{'argInfo': {'objectPath': {'doc': 'Path of object to test ',
                                                                                   'type': 'MDagPath'}},
                                                        'args': [('objectPath',
                                                                  'MDagPath',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns true if the specified path is in the current render layer.',
                                                        'inArgs': ['objectPath'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'true if the object is in the current render layer.',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': True,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'objectPath': ['const',
                                                                                          '&']},
                                                        'types': {'objectPath': 'MDagPath'}}],
                              'lightAttenuation': [{'argInfo': {'lightBackFace': {'doc': 'Is the back face being lit, true or false. ',
                                                                                  'type': 'bool'},
                                                                'lightBlindData': {'doc': 'The reference to the aLightBlindData attribute of the current light being evaluated ',
                                                                                   'type': 'void'},
                                                                'normal': {'doc': 'The surface normal ',
                                                                           'type': 'MFloatVector'},
                                                                'pointCamera': {'doc': 'The position of the camera ',
                                                                                'type': 'MFloatVector'}},
                                                    'args': [('lightBlindData',
                                                              'void',
                                                              'in'),
                                                             ('pointCamera',
                                                              'MFloatVector',
                                                              'in'),
                                                             ('normal',
                                                              'MFloatVector',
                                                              'in'),
                                                             ('lightBackFace',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis utility function computes and returns light attentuation factor of a light. Note that the result of 1 will be returned if the light being evaluated does not support light attentuation.',
                                                    'inArgs': ['lightBlindData',
                                                               'pointCamera',
                                                               'normal',
                                                               'lightBackFace'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'float'},
                                                    'returnType': 'float',
                                                    'static': True,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'lightBackFace': [],
                                                                       'lightBlindData': ['const',
                                                                                          '*'],
                                                                       'normal': ['const',
                                                                                  '&'],
                                                                       'pointCamera': ['const',
                                                                                       '&']},
                                                    'types': {'lightBackFace': 'bool',
                                                              'lightBlindData': 'void',
                                                              'normal': 'MFloatVector',
                                                              'pointCamera': 'MFloatVector'}}],
                              'mainBeautyPassCustomTokenString': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nReturns the custom token string of the main beauty pass for use by renderers in file naming.',
                                                                   'inArgs': [],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MString'},
                                                                   'returnType': 'MString',
                                                                   'static': True,
                                                                   'typeQualifiers': {},
                                                                   'types': {}}],
                              'mainBeautyPassName': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the name of the main beauty pass for use by renderers for token substitution.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': True,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                              'maximumSpecularReflection': [{'argInfo': {'lightBlindData': {'doc': 'The reference to the aLightBlindData attribute of the current light being evaluated ',
                                                                                            'type': 'void'},
                                                                         'lightDirection': {'doc': 'The direction of the light being evaluated ',
                                                                                            'type': 'MFloatVector'},
                                                                         'normal': {'doc': 'The surface normal ',
                                                                                    'type': 'MFloatVector'},
                                                                         'pointCamera': {'doc': 'The position of the camera ',
                                                                                         'type': 'MFloatVector'},
                                                                         'rayDirection': {'doc': 'The direction of the current intersection ray in camera space ',
                                                                                          'type': 'MFloatVector'}},
                                                             'args': [('lightBlindData',
                                                                       'void',
                                                                       'in'),
                                                                      ('lightDirection',
                                                                       'MFloatVector',
                                                                       'in'),
                                                                      ('pointCamera',
                                                                       'MFloatVector',
                                                                       'in'),
                                                                      ('normal',
                                                                       'MFloatVector',
                                                                       'in'),
                                                                      ('rayDirection',
                                                                       'MFloatVector',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nThis utility function computes and returns the vector corresponding to the point on the light source that provides the maximum specular reflection.',
                                                             'inArgs': ['lightBlindData',
                                                                        'lightDirection',
                                                                        'pointCamera',
                                                                        'normal',
                                                                        'rayDirection'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': 'MFloatVector'},
                                                             'returnType': 'MFloatVector',
                                                             'static': True,
                                                             'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                'lightBlindData': ['const',
                                                                                                   '*'],
                                                                                'lightDirection': ['const',
                                                                                                   '&'],
                                                                                'normal': ['const',
                                                                                           '&'],
                                                                                'pointCamera': ['const',
                                                                                                '&'],
                                                                                'rayDirection': ['const',
                                                                                                 '&']},
                                                             'types': {'lightBlindData': 'void',
                                                                       'lightDirection': 'MFloatVector',
                                                                       'normal': 'MFloatVector',
                                                                       'pointCamera': 'MFloatVector',
                                                                       'rayDirection': 'MFloatVector'}}],
                              'mayaRenderState': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns an enumerated type specifying the current state of the Maya renderer.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': ('MRenderUtil',
                                                                           'MRenderState')},
                                                   'returnType': ('MRenderUtil',
                                                                  'MRenderState'),
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                              'noise1': [{'argInfo': {'x': {'doc': 'The one dimensional coordinate for which to generate noise',
                                                            'type': 'float'}},
                                          'args': [('x', 'float', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nGenerates continous non-repeating one dimensional noise based on Maya's internal noise table.",
                                          'inArgs': ['x'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A noise value that is non-repeating and continuous on the given coordinate ',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': True,
                                          'typeQualifiers': {'x': []},
                                          'types': {'x': 'float'}}],
                              'noise2': [{'argInfo': {'x': {'doc': 'The x coordinate for which to generate noise ',
                                                            'type': 'float'},
                                                      'y': {'doc': 'The y coordinate for which to generate noise',
                                                            'type': 'float'}},
                                          'args': [('x', 'float', 'in'),
                                                   ('y', 'float', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nGenerates continous non-repeating two dimensional noise based on Maya's internal noise table.",
                                          'inArgs': ['x', 'y'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A noise value that is non-repeating and continuous on the given coordinate ',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': True,
                                          'typeQualifiers': {'x': [],
                                                             'y': []},
                                          'types': {'x': 'float',
                                                    'y': 'float'}}],
                              'noise3': [{'argInfo': {'x': {'doc': 'The x coordinate for which to generate noise ',
                                                            'type': 'float'},
                                                      'y': {'doc': 'The y coordinate for which to generate noise ',
                                                            'type': 'float'},
                                                      'z': {'doc': 'The y coordinate for which to generate noise',
                                                            'type': 'float'}},
                                          'args': [('x', 'float', 'in'),
                                                   ('y', 'float', 'in'),
                                                   ('z', 'float', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nGenerates continous non-repeating three dimensional noise based on Maya's internal noise table.",
                                          'inArgs': ['x', 'y', 'z'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A noise value that is non-repeating and continuous on the given coordinate ',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': True,
                                          'typeQualifiers': {'x': [],
                                                             'y': [],
                                                             'z': []},
                                          'types': {'x': 'float',
                                                    'y': 'float',
                                                    'z': 'float'}}],
                              'noise4': [{'argInfo': {'numTimeSteps': {'doc': 'Controls the repetition of the noise with respect to time',
                                                                       'type': 'short'},
                                                      't': {'doc': 'The time coordinate for which to generate noise ',
                                                            'type': 'float'},
                                                      'x': {'doc': 'The x coordinate for which to generate noise ',
                                                            'type': 'float'},
                                                      'y': {'doc': 'The y coordinate for which to generate noise ',
                                                            'type': 'float'},
                                                      'z': {'doc': 'The y coordinate for which to generate noise ',
                                                            'type': 'float'}},
                                          'args': [('x', 'float', 'in'),
                                                   ('y', 'float', 'in'),
                                                   ('z', 'float', 'in'),
                                                   ('t', 'float', 'in'),
                                                   ('numTimeSteps',
                                                    'short',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "\r\nGenerates continous four dimensional (space + time) noise based on Maya's internal noise table. The noise will loop in a seamless manner. The larger the value for the numTimeSteps parameter the longer it will take for the noise to loop (i.e. more samples would be required along the time axis to cause the sequence to restart).",
                                          'inArgs': ['x',
                                                     'y',
                                                     'z',
                                                     't',
                                                     'numTimeSteps'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A noise value that is continuous on the given coordinate ',
                                                         'qualifiers': [],
                                                         'type': 'float'},
                                          'returnType': 'float',
                                          'static': True,
                                          'typeQualifiers': {'numTimeSteps': ['unsigned'],
                                                             't': [],
                                                             'x': [],
                                                             'y': [],
                                                             'z': []},
                                          'types': {'numTimeSteps': 'short',
                                                    't': 'float',
                                                    'x': 'float',
                                                    'y': 'float',
                                                    'z': 'float'}}],
                              'noiseTableCubeSide': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "\r\nThe size of Maya's noise table is a perfect cube. This method returns the cubic root of the table size.",
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': True,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                              'noiseTableSize': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "\r\nAccess the size of Maya's noise table. The noise table is a constant set of random floating point values in the range [-1.0, 1.0] used by many of Maya's procedural textures.",
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                              'raytrace': [{'argInfo': {'isReflectedRays': {'doc': 'true for reflected rays (default), false for refracted rays',
                                                                            'type': 'bool'},
                                                        'notUsed': {'doc': 'unused argument left for compatibility ',
                                                                    'type': 'void'},
                                                        'rayDepth': {'doc': 'Current ray depth from the renderer ',
                                                                     'type': 'short'},
                                                        'rayDirection': {'doc': 'Direction of the ray to shoot at in camera space ',
                                                                         'type': 'MFloatVector'},
                                                        'rayOrigin': {'doc': 'Origin of the ray to shoot from in camera space ',
                                                                      'type': 'MFloatVector'},
                                                        'raySampler': {'doc': 'Pointer to the raytracer from the renderer ',
                                                                       'type': 'void'},
                                                        'resultColor': {'doc': 'Storage for the result color ',
                                                                        'type': 'MFloatVector'},
                                                        'resultTransparency': {'doc': 'Storage for the result transparency ',
                                                                               'type': 'MFloatVector'}},
                                            'args': [('rayOrigin',
                                                      'MFloatVector',
                                                      'in'),
                                                     ('rayDirection',
                                                      'MFloatVector',
                                                      'in'),
                                                     ('notUsed',
                                                      'void',
                                                      'in'),
                                                     ('raySampler',
                                                      'void',
                                                      'in'),
                                                     ('rayDepth',
                                                      'short',
                                                      'in'),
                                                     ('resultColor',
                                                      'MFloatVector',
                                                      'out'),
                                                     ('resultTransparency',
                                                      'MFloatVector',
                                                      'out'),
                                                     ('isReflectedRays',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'isReflectedRays': True},
                                            'deprecated': False,
                                            'doc': '\r\nThis utility method provides functionality to raytrace from within a shader plug-in.',
                                            'inArgs': ['rayOrigin',
                                                       'rayDirection',
                                                       'notUsed',
                                                       'raySampler',
                                                       'rayDepth',
                                                       'isReflectedRays'],
                                            'outArgs': ['resultColor',
                                                        'resultTransparency'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'isReflectedRays': ['const'],
                                                               'notUsed': ['const',
                                                                           '*'],
                                                               'rayDepth': ['const'],
                                                               'rayDirection': ['const',
                                                                                '&'],
                                                               'rayOrigin': ['const',
                                                                             '&'],
                                                               'raySampler': ['const',
                                                                              '*'],
                                                               'resultColor': ['&'],
                                                               'resultTransparency': ['&']},
                                            'types': {'isReflectedRays': 'bool',
                                                      'notUsed': 'void',
                                                      'rayDepth': 'short',
                                                      'rayDirection': 'MFloatVector',
                                                      'rayOrigin': 'MFloatVector',
                                                      'raySampler': 'void',
                                                      'resultColor': 'MFloatVector',
                                                      'resultTransparency': 'MFloatVector'}},
                                           {'argInfo': {'isReflectedRays': {'doc': 'true for reflected rays (default), false for refracted rays',
                                                                            'type': 'bool'},
                                                        'notUsed': {'doc': 'unused argument left for compatability ',
                                                                    'type': 'void'},
                                                        'rayDepth': {'doc': 'Current ray depth from the renderer ',
                                                                     'type': 'short'},
                                                        'rayDirections': {'doc': 'Directions of the ray to shoot at in camera space ',
                                                                          'type': 'MFloatVectorArray'},
                                                        'rayOrigins': {'doc': 'Origins of the ray to shoot from in camera space ',
                                                                       'type': 'MFloatVectorArray'},
                                                        'raySampler': {'doc': 'Pointer to the raytracer from the renderer ',
                                                                       'type': 'void'},
                                                        'resultColors': {'doc': 'Storage for the result colors ',
                                                                         'type': 'MFloatVectorArray'},
                                                        'resultTransparencies': {'doc': 'Storage for the result transparencies ',
                                                                                 'type': 'MFloatVectorArray'}},
                                            'args': [('rayOrigins',
                                                      'MFloatVectorArray',
                                                      'in'),
                                                     ('rayDirections',
                                                      'MFloatVectorArray',
                                                      'in'),
                                                     ('notUsed',
                                                      'void',
                                                      'in'),
                                                     ('raySampler',
                                                      'void',
                                                      'in'),
                                                     ('rayDepth',
                                                      'short',
                                                      'in'),
                                                     ('resultColors',
                                                      'MFloatVectorArray',
                                                      'out'),
                                                     ('resultTransparencies',
                                                      'MFloatVectorArray',
                                                      'out'),
                                                     ('isReflectedRays',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'isReflectedRays': True},
                                            'deprecated': False,
                                            'doc': '\r\nThis utility method provides functionality to raytrace from within a shader plug-in.',
                                            'inArgs': ['rayOrigins',
                                                       'rayDirections',
                                                       'notUsed',
                                                       'raySampler',
                                                       'rayDepth',
                                                       'isReflectedRays'],
                                            'outArgs': ['resultColors',
                                                        'resultTransparencies'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'isReflectedRays': ['const'],
                                                               'notUsed': ['const',
                                                                           '*'],
                                                               'rayDepth': ['const'],
                                                               'rayDirections': ['const',
                                                                                 '&'],
                                                               'rayOrigins': ['const',
                                                                              '&'],
                                                               'raySampler': ['const',
                                                                              '*'],
                                                               'resultColors': ['&'],
                                                               'resultTransparencies': ['&']},
                                            'types': {'isReflectedRays': 'bool',
                                                      'notUsed': 'void',
                                                      'rayDepth': 'short',
                                                      'rayDirections': 'MFloatVectorArray',
                                                      'rayOrigins': 'MFloatVectorArray',
                                                      'raySampler': 'void',
                                                      'resultColors': 'MFloatVectorArray',
                                                      'resultTransparencies': 'MFloatVectorArray'}}],
                              'raytraceFirstGeometryIntersections': [{'argInfo': {'notUsed': {'doc': 'unused argument left for compatability ',
                                                                                              'type': 'void'},
                                                                                  'rayDirections': {'doc': 'Directions of the ray to shoot at in camera space ',
                                                                                                    'type': 'MFloatVectorArray'},
                                                                                  'rayOrigins': {'doc': 'Origins of the ray to shoot from in camera space ',
                                                                                                 'type': 'MFloatVectorArray'},
                                                                                  'raySampler': {'doc': 'Pointer to the raytracer from the renderer ',
                                                                                                 'type': 'void'},
                                                                                  'resultIntersected': {'doc': 'Storage for the result intersected flags (0 = no geometry intersected, 1 = geometry intersected)',
                                                                                                        'type': 'MIntArray'},
                                                                                  'resultIntersections': {'doc': 'Storage for the result intersection locations in camera space ',
                                                                                                          'type': 'MFloatVectorArray'}},
                                                                      'args': [('rayOrigins',
                                                                                'MFloatVectorArray',
                                                                                'in'),
                                                                               ('rayDirections',
                                                                                'MFloatVectorArray',
                                                                                'in'),
                                                                               ('notUsed',
                                                                                'void',
                                                                                'in'),
                                                                               ('raySampler',
                                                                                'void',
                                                                                'in'),
                                                                               ('resultIntersections',
                                                                                'MFloatVectorArray',
                                                                                'out'),
                                                                               ('resultIntersected',
                                                                                'MIntArray',
                                                                                'out')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\r\nThis utility method provides functionality to find the location of the first geometry intersected by a ray from within a shader plug-in.',
                                                                      'inArgs': ['rayOrigins',
                                                                                 'rayDirections',
                                                                                 'notUsed',
                                                                                 'raySampler'],
                                                                      'outArgs': ['resultIntersections',
                                                                                  'resultIntersected'],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': None},
                                                                      'returnType': None,
                                                                      'static': True,
                                                                      'typeQualifiers': {'notUsed': ['const',
                                                                                                     '*'],
                                                                                         'rayDirections': ['const',
                                                                                                           '&'],
                                                                                         'rayOrigins': ['const',
                                                                                                        '&'],
                                                                                         'raySampler': ['const',
                                                                                                        '*'],
                                                                                         'resultIntersected': ['&'],
                                                                                         'resultIntersections': ['&']},
                                                                      'types': {'notUsed': 'void',
                                                                                'rayDirections': 'MFloatVectorArray',
                                                                                'rayOrigins': 'MFloatVectorArray',
                                                                                'raySampler': 'void',
                                                                                'resultIntersected': 'MIntArray',
                                                                                'resultIntersections': 'MFloatVectorArray'}}],
                              'relativeFileName': [{'argInfo': {'absFileName': {'doc': 'input file name ',
                                                                                'type': 'MString'}},
                                                    'args': [('absFileName',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nExtract relative file name from the given (absolute) file name. If the given file name does not begin with a project root, return value is same as the input file name.',
                                                    'inArgs': ['absFileName'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': ' file name without the project path  ',
                                                                   'qualifiers': [],
                                                                   'type': 'MString'},
                                                    'returnType': 'MString',
                                                    'static': True,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'absFileName': ['const',
                                                                                       '&']},
                                                    'types': {'absFileName': 'MString'}}],
                              'renderObjectItem': [{'argInfo': {'item': {'doc': 'The corresponding item for the id',
                                                                         'type': 'MSelectionList'},
                                                                'objectId': {'doc': 'The sample object id to look-up ',
                                                                             'type': 'void'}},
                                                    'args': [('objectId',
                                                              'void',
                                                              'in'),
                                                             ('item',
                                                              'MSelectionList',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nProcedure to look up a selection item for a given sample object id. This is only guaranteed to work when software rendering. As multiple processors may be used when software rendering; a critical section should be used to protect multiple threads from simulaneously performing DG evaluation. This includes querying attribute values.',
                                                    'inArgs': ['objectId',
                                                               'item'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'item': ['&'],
                                                                       'objectId': ['const',
                                                                                    '*']},
                                                    'types': {'item': 'MSelectionList',
                                                              'objectId': 'void'}}],
                              'renderPass': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns an enumerated type specifying the current pass the Maya renderer is executing.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MRenderUtil',
                                                                      'MRenderPass')},
                                              'returnType': ('MRenderUtil',
                                                             'MRenderPass'),
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'sampleShadingNetwork': [{'argInfo': {'cameraMatrix': {'doc': 'The eyeToWorld matrix to be used for conversion ',
                                                                                     'type': 'MFloatMatrix'},
                                                                    'filterSizes': {'doc': 'Filter sizes to be used for 2D/3D textures ',
                                                                                    'type': 'MFloatArray'},
                                                                    'normals': {'doc': 'Normals at the sample points in world space ',
                                                                                'type': 'MFloatVectorArray'},
                                                                    'numSamples': {'doc': 'Number of samples to be calculated ',
                                                                                   'type': 'int'},
                                                                    'points': {'doc': 'Locations to be sampled in world space ',
                                                                               'type': 'MFloatPointArray'},
                                                                    'refPoints': {'doc': 'RefPoints to be used for 3D texture in world space ',
                                                                                  'type': 'MFloatPointArray'},
                                                                    'resultColors': {'doc': 'Storage for result colors ',
                                                                                     'type': 'MFloatVectorArray'},
                                                                    'resultTransparencies': {'doc': 'storage for result transparencies',
                                                                                             'type': 'MFloatVectorArray'},
                                                                    'reuseMaps': {'doc': 'If calculating shadows, whether to reuse shadowmaps ',
                                                                                  'type': 'bool'},
                                                                    'shadingNodeName': {'doc': 'Name of the shading node/shading engine ',
                                                                                        'type': 'MString'},
                                                                    'tangentUs': {'doc': 'U tangents at the sample points in world space ',
                                                                                  'type': 'MFloatVectorArray'},
                                                                    'tangentVs': {'doc': 'V tangents at the sample points in world space ',
                                                                                  'type': 'MFloatVectorArray'},
                                                                    'uCoords': {'doc': 'U coordinates of the samples ',
                                                                                'type': 'MFloatArray'},
                                                                    'useShadowMaps': {'doc': 'Whether to calculate shadows ',
                                                                                      'type': 'bool'},
                                                                    'vCoords': {'doc': 'V coordinates of the samples ',
                                                                                'type': 'MFloatArray'}},
                                                        'args': [('shadingNodeName',
                                                                  'MString',
                                                                  'in'),
                                                                 ('numSamples',
                                                                  'int',
                                                                  'in'),
                                                                 ('useShadowMaps',
                                                                  'bool',
                                                                  'in'),
                                                                 ('reuseMaps',
                                                                  'bool',
                                                                  'in'),
                                                                 ('cameraMatrix',
                                                                  'MFloatMatrix',
                                                                  'in'),
                                                                 ('points',
                                                                  'MFloatPointArray',
                                                                  'in'),
                                                                 ('uCoords',
                                                                  'MFloatArray',
                                                                  'in'),
                                                                 ('vCoords',
                                                                  'MFloatArray',
                                                                  'in'),
                                                                 ('normals',
                                                                  'MFloatVectorArray',
                                                                  'in'),
                                                                 ('refPoints',
                                                                  'MFloatPointArray',
                                                                  'in'),
                                                                 ('tangentUs',
                                                                  'MFloatVectorArray',
                                                                  'in'),
                                                                 ('tangentVs',
                                                                  'MFloatVectorArray',
                                                                  'in'),
                                                                 ('filterSizes',
                                                                  'MFloatArray',
                                                                  'in'),
                                                                 ('resultColors',
                                                                  'MFloatVectorArray',
                                                                  'out'),
                                                                 ('resultTransparencies',
                                                                  'MFloatVectorArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis utility method allows you to sample a shading node/shading engine. You can specify the location and property of the sample point, and the method will return the result color and transparency. If you are sampling a shading engine, and there are lights in the scene, you can optionally request shadows to be computed as well.',
                                                        'inArgs': ['shadingNodeName',
                                                                   'numSamples',
                                                                   'useShadowMaps',
                                                                   'reuseMaps',
                                                                   'cameraMatrix',
                                                                   'points',
                                                                   'uCoords',
                                                                   'vCoords',
                                                                   'normals',
                                                                   'refPoints',
                                                                   'tangentUs',
                                                                   'tangentVs',
                                                                   'filterSizes'],
                                                        'outArgs': ['resultColors',
                                                                    'resultTransparencies'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': True,
                                                        'typeQualifiers': {'cameraMatrix': ['&'],
                                                                           'filterSizes': ['*'],
                                                                           'normals': ['*'],
                                                                           'numSamples': [],
                                                                           'points': ['*'],
                                                                           'refPoints': ['*'],
                                                                           'resultColors': ['&'],
                                                                           'resultTransparencies': ['&'],
                                                                           'reuseMaps': [],
                                                                           'shadingNodeName': [],
                                                                           'tangentUs': ['*'],
                                                                           'tangentVs': ['*'],
                                                                           'uCoords': ['*'],
                                                                           'useShadowMaps': [],
                                                                           'vCoords': ['*']},
                                                        'types': {'cameraMatrix': 'MFloatMatrix',
                                                                  'filterSizes': 'MFloatArray',
                                                                  'normals': 'MFloatVectorArray',
                                                                  'numSamples': 'int',
                                                                  'points': 'MFloatPointArray',
                                                                  'refPoints': 'MFloatPointArray',
                                                                  'resultColors': 'MFloatVectorArray',
                                                                  'resultTransparencies': 'MFloatVectorArray',
                                                                  'reuseMaps': 'bool',
                                                                  'shadingNodeName': 'MString',
                                                                  'tangentUs': 'MFloatVectorArray',
                                                                  'tangentVs': 'MFloatVectorArray',
                                                                  'uCoords': 'MFloatArray',
                                                                  'useShadowMaps': 'bool',
                                                                  'vCoords': 'MFloatArray'}}],
                              'sendRenderProgressInfo': [{'argInfo': {'percentageDone': {'doc': 'percentage rendered ',
                                                                                         'type': 'int'},
                                                                      'pixFile': {'doc': 'File name of the last rendered batch image ',
                                                                                  'type': 'MString'}},
                                                          'args': [('pixFile',
                                                                    'MString',
                                                                    'in'),
                                                                   ('percentageDone',
                                                                    'int',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis utility function sends batch rendering status to Maya',
                                                          'inArgs': ['pixFile',
                                                                     'percentageDone'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': True,
                                                          'typeQualifiers': {'percentageDone': [],
                                                                             'pixFile': ['const',
                                                                                         '&']},
                                                          'types': {'percentageDone': 'int',
                                                                    'pixFile': 'MString'}}],
                              'valueInNoiseTable': [{'argInfo': {'index': {'doc': 'The index to retrieve from the noise table',
                                                                           'type': 'uint'}},
                                                     'args': [('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': "\r\nReturns a raw value from Maya's noise table at the given index. If the index is out of bounds, the index modulo  noiseTableSize()  is used instead. The noise table is a constant set of random floating point values in the range [-1.0, 1.0] used by many of Maya's procedural textures.",
                                                     'inArgs': ['index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'A value from the noise table in the range [-1.0, 1.0] ',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': True,
                                                     'typeQualifiers': {'index': ['unsigned']},
                                                     'types': {'index': 'uint'}}]},
                  'pymelEnums': {'MRenderPass': "Enum('MRenderPass', [('all', 0), ('kAll', 0), ('colorOnly', 1), ('kColorOnly', 1), ('shadowOnly', 2), ('kShadowOnly', 2), ('ambientOnly', 3), ('kAmbientOnly', 3), ('diffuseOnly', 4), ('kDiffuseOnly', 4), ('specularOnly', 5), ('kSpecularOnly', 5)], multiKeys=True)",
                                 'MRenderState': "Enum('MRenderState', [('notRendering', 0), ('kNotRendering', 0), ('batchRender', 1), ('kBatchRender', 1), ('interactiveRender', 2), ('kInteractiveRender', 2), ('iprRender', 3), ('kIprRender', 3), ('hardwareRender', 4), ('kHardwareRender', 4)], multiKeys=True)"}},
  'MRenderView': {'enums': {},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['char*'],
                                                            'type': 'static'},
                                             'returnType': 'static',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'doesRenderEditorExist': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nDetermines whether or not a Render View exists to receive image data. If this function returns false, then Maya is currently running in batch mode, so it would be pointless to try to send data to the Render View.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': ' true if the Render View exists.  false otherwise.   ',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                              'endRender': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nInforms the Render View that the current render has completed. The Render View is refreshed and no further updates are accepted.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'getRenderRegion': [{'argInfo': {'bottom': {'doc': 'receives the bottom extent of the region ',
                                                                          'type': 'uint'},
                                                               'left': {'doc': 'receives the left extent of the region ',
                                                                        'type': 'uint'},
                                                               'right': {'doc': 'receives the right extent of the region ',
                                                                         'type': 'uint'},
                                                               'top': {'doc': 'receives the top extent of the region',
                                                                       'type': 'uint'}},
                                                   'args': [('left',
                                                             'uint',
                                                             'out'),
                                                            ('right',
                                                             'uint',
                                                             'out'),
                                                            ('bottom',
                                                             'uint',
                                                             'out'),
                                                            ('top',
                                                             'uint',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "\r\nRetrieves the currently selected Render Region in Maya's Render View. The region extends from the bottom-left corner (left,bottom) to the upper-right corner (right,top) inclusive (i.e. the row y=top and column x=right are part of the region).",
                                                   'inArgs': [],
                                                   'outArgs': ['left',
                                                               'right',
                                                               'bottom',
                                                               'top'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'bottom': ['unsigned',
                                                                                 '&'],
                                                                      'left': ['unsigned',
                                                                               '&'],
                                                                      'right': ['unsigned',
                                                                                '&'],
                                                                      'top': ['unsigned',
                                                                              '&']},
                                                   'types': {'bottom': 'uint',
                                                             'left': 'uint',
                                                             'right': 'uint',
                                                             'top': 'uint'}}],
                              'refresh': [{'argInfo': {'bottom': {'doc': 'bottom extent of the update region. ',
                                                                  'type': 'uint'},
                                                       'left': {'doc': 'left extent of the update region. ',
                                                                'type': 'uint'},
                                                       'right': {'doc': 'right extent of the update region. The column x=right is considered part of the region. ',
                                                                 'type': 'uint'},
                                                       'top': {'doc': 'top extent of the update region. The row y=regionTop is considered part of the region.',
                                                               'type': 'uint'}},
                                           'args': [('left',
                                                     'uint',
                                                     'in'),
                                                    ('right',
                                                     'uint',
                                                     'in'),
                                                    ('bottom',
                                                     'uint',
                                                     'in'),
                                                    ('top',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRequests that the Render View refresh the display of a particular region of the displayed image.',
                                           'inArgs': ['left',
                                                      'right',
                                                      'bottom',
                                                      'top'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'bottom': ['unsigned'],
                                                              'left': ['unsigned'],
                                                              'right': ['unsigned'],
                                                              'top': ['unsigned']},
                                           'types': {'bottom': 'uint',
                                                     'left': 'uint',
                                                     'right': 'uint',
                                                     'top': 'uint'}}],
                              'setCurrentCamera': [{'argInfo': {'currentCamera': {'doc': 'Camera to be used in the render.',
                                                                                  'type': 'MDagPath'}},
                                                    'args': [('currentCamera',
                                                              'MDagPath',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nInforms the render client of the camera that will be performing the rendering.',
                                                    'inArgs': ['currentCamera'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'currentCamera': ['&']},
                                                    'types': {'currentCamera': 'MDagPath'}}],
                              'startRegionRender': [{'argInfo': {'doNotClearBackground': {'doc': 'When true, the Render View is not cleared before starting to draw. Default (false) is to clear the Render View. ',
                                                                                          'type': 'bool'},
                                                                 'imageHeight': {'doc': 'height of the image in which the region is embedded (must be greater than zero). ',
                                                                                 'type': 'uint'},
                                                                 'imageWidth': {'doc': 'width of the image in which the region is embedded. (must be greater than zero). ',
                                                                                'type': 'uint'},
                                                                 'immediateFeedback': {'doc': 'When true, each call to refresh() will immediately redraw the Render View. Default (false) is to wait at least two seconds between redraws.',
                                                                                       'type': 'bool'},
                                                                 'regionBottom': {'doc': 'bottom extent of the region. ',
                                                                                  'type': 'uint'},
                                                                 'regionLeft': {'doc': 'left extent of the region. ',
                                                                                'type': 'uint'},
                                                                 'regionRight': {'doc': 'right extent of the region. The column x=regionRight is considered part of the region. ',
                                                                                 'type': 'uint'},
                                                                 'regionTop': {'doc': 'top extent of the region. The row y=regionTop is considered part of the region. ',
                                                                               'type': 'uint'}},
                                                     'args': [('imageWidth',
                                                               'uint',
                                                               'in'),
                                                              ('imageHeight',
                                                               'uint',
                                                               'in'),
                                                              ('regionLeft',
                                                               'uint',
                                                               'in'),
                                                              ('regionRight',
                                                               'uint',
                                                               'in'),
                                                              ('regionBottom',
                                                               'uint',
                                                               'in'),
                                                              ('regionTop',
                                                               'uint',
                                                               'in'),
                                                              ('doNotClearBackground',
                                                               'bool',
                                                               'in'),
                                                              ('immediateFeedback',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {'doNotClearBackground': False,
                                                                  'immediateFeedback': False},
                                                     'deprecated': False,
                                                     'doc': "\r\nInforms the Render View that a region render is about to begin. The specified region will be cleared in anticipation of receiving new image data for it. The specified region must lie within the image region (0,0)->(imageWidth-1,imageHeight-1). The region 'left' coordinate must be less than the region 'right' coordinate, and the region 'bottom' coordinate must be less than the region 'top' coordinate.",
                                                     'inArgs': ['imageWidth',
                                                                'imageHeight',
                                                                'regionLeft',
                                                                'regionRight',
                                                                'regionBottom',
                                                                'regionTop',
                                                                'doNotClearBackground',
                                                                'immediateFeedback'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': True,
                                                     'typeQualifiers': {'doNotClearBackground': [],
                                                                        'imageHeight': ['unsigned'],
                                                                        'imageWidth': ['unsigned'],
                                                                        'immediateFeedback': [],
                                                                        'regionBottom': ['unsigned'],
                                                                        'regionLeft': ['unsigned'],
                                                                        'regionRight': ['unsigned'],
                                                                        'regionTop': ['unsigned']},
                                                     'types': {'doNotClearBackground': 'bool',
                                                               'imageHeight': 'uint',
                                                               'imageWidth': 'uint',
                                                               'immediateFeedback': 'bool',
                                                               'regionBottom': 'uint',
                                                               'regionLeft': 'uint',
                                                               'regionRight': 'uint',
                                                               'regionTop': 'uint'}}],
                              'startRender': [{'argInfo': {'doNotClearBackground': {'doc': 'When true, the Render View is not cleared before starting to draw. Default (false) is to clear the Render View. ',
                                                                                    'type': 'bool'},
                                                           'height': {'doc': 'height of the image to be sent to the Render View (must be greater than zero). ',
                                                                      'type': 'uint'},
                                                           'immediateFeedback': {'doc': 'When true, each call to refresh() will immediately redraw the Render View. Default (false) is to wait at least two seconds between redraws.',
                                                                                 'type': 'bool'},
                                                           'width': {'doc': 'width of the image to be sent to the Render View (must be greater than zero). ',
                                                                     'type': 'uint'}},
                                               'args': [('width',
                                                         'uint',
                                                         'in'),
                                                        ('height',
                                                         'uint',
                                                         'in'),
                                                        ('doNotClearBackground',
                                                         'bool',
                                                         'in'),
                                                        ('immediateFeedback',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'doNotClearBackground': False,
                                                            'immediateFeedback': False},
                                               'deprecated': False,
                                               'doc': '\r\nInforms the Render View that a full image render is about to begin. The entire Render View buffer will be cleared in anticipation of receiving an entire image.',
                                               'inArgs': ['width',
                                                          'height',
                                                          'doNotClearBackground',
                                                          'immediateFeedback'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'doNotClearBackground': [],
                                                                  'height': ['unsigned'],
                                                                  'immediateFeedback': [],
                                                                  'width': ['unsigned']},
                                               'types': {'doNotClearBackground': 'bool',
                                                         'height': 'uint',
                                                         'immediateFeedback': 'bool',
                                                         'width': 'uint'}}],
                              'updatePixels': [{'argInfo': {'bottom': {'doc': 'bottom extent of the update region. ',
                                                                       'type': 'uint'},
                                                            'isHdr': {'doc': 'indicates whether the image has high dynamic range ',
                                                                      'type': 'bool'},
                                                            'left': {'doc': 'left extent of the update region. ',
                                                                     'type': 'uint'},
                                                            'numberOfAOVs': {'doc': 'indicates the number of arbitrary output variable (AOV) buffers (not yet implemented). ',
                                                                             'type': 'uint'},
                                                            'pAOVs': {'doc': 'array of RV_AOV objects. The height and width of each AOV must match pPixels (not yet implemented).',
                                                                      'type': 'RV_AOV'},
                                                            'pPixels': {'doc': 'buffer containing the pixel data for the image. The buffer should contain (right-left+1)*(top-bottom+1) pixels. ',
                                                                        'type': 'RV_PIXEL'},
                                                            'right': {'doc': 'right extent of the update region. The column x=right is considered part of the region. ',
                                                                      'type': 'uint'},
                                                            'top': {'doc': 'top extent of the update region. The row y=regionTop is considered part of the region. ',
                                                                    'type': 'uint'}},
                                                'args': [('left',
                                                          'uint',
                                                          'in'),
                                                         ('right',
                                                          'uint',
                                                          'in'),
                                                         ('bottom',
                                                          'uint',
                                                          'in'),
                                                         ('top',
                                                          'uint',
                                                          'in'),
                                                         ('pPixels',
                                                          'RV_PIXEL',
                                                          'in'),
                                                         ('isHdr',
                                                          'bool',
                                                          'in'),
                                                         ('numberOfAOVs',
                                                          'uint',
                                                          'in'),
                                                         ('pAOVs',
                                                          'RV_AOV',
                                                          'in')],
                                                'defaults': {'isHdr': False,
                                                             'numberOfAOVs': 0,
                                                             'pAOVs': None},
                                                'deprecated': False,
                                                'doc': '\r\nSends a block of pixels to the Render View. Pixel colors are represented as 4-channel floating point values. For low dynamic range images, color values are in standard RGB (sRGB) colorspace, and in the range (0,255.0). For high dynamic range (HDR) images, the range is unbounded, and values are in linear CIE XYZ color space, with the X, Y, and Z values stored respectively in the R, G and B fields of the  RV_PIXEL  structure. Alpha values for HDR images are expected to be in the range (0,1). Out of range alpha values are not clamped, and may behave unexpectedly.',
                                                'inArgs': ['left',
                                                           'right',
                                                           'bottom',
                                                           'top',
                                                           'pPixels',
                                                           'isHdr',
                                                           'numberOfAOVs',
                                                           'pAOVs'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'bottom': ['unsigned'],
                                                                   'isHdr': [],
                                                                   'left': ['unsigned'],
                                                                   'numberOfAOVs': ['const',
                                                                                    'unsigned'],
                                                                   'pAOVs': ['const',
                                                                             '*const'],
                                                                   'pPixels': ['*'],
                                                                   'right': ['unsigned'],
                                                                   'top': ['unsigned']},
                                                'types': {'bottom': 'uint',
                                                          'isHdr': 'bool',
                                                          'left': 'uint',
                                                          'numberOfAOVs': 'uint',
                                                          'pAOVs': 'RV_AOV',
                                                          'pPixels': 'RV_PIXEL',
                                                          'right': 'uint',
                                                          'top': 'uint'}}]},
                  'pymelEnums': {}},
  'MRenderingInfo': {'enums': {},
                     'methods': {'cameraPath': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCurrent camera being used to render with. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Dag path to camera. ',
                                                                'qualifiers': ['&'],
                                                                'type': 'MDagPath'},
                                                 'returnType': 'MDagPath',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                 'height': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nHeight of region to render in pixels. \r\n',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                 'originX': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nOrigin (x) of region to render to in pixels. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'originY': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nOrigin (y) of region to render to in pixels. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'projectionMatrix': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nCurrent projection matrix. \r\n',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Projection matrix. ',
                                                                      'qualifiers': ['&'],
                                                                      'type': 'MMatrix'},
                                                       'returnType': 'MMatrix',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                 'renderTarget': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nCurrent render target. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Reference to render target. ',
                                                                  'qualifiers': ['&'],
                                                                  'type': 'MRenderTargetLegacy'},
                                                   'returnType': 'MRenderTargetLegacy',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'renderingAPI': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nNative target rendering API. \r\n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Rendering API. ',
                                                                  'qualifiers': [],
                                                                  'type': ('MViewportRenderer',
                                                                           'RenderingAPI')},
                                                   'returnType': ('MViewportRenderer',
                                                                  'RenderingAPI'),
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'renderingVersion': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nNative target rendering version. \r\n',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'float'},
                                                       'returnType': 'float',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                 'viewMatrix': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nCurrent view matrix. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'View matrix. ',
                                                                'qualifiers': ['&'],
                                                                'type': 'MMatrix'},
                                                 'returnType': 'MMatrix',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                 'width': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nWidth of region to render in pixels. \r\n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                     'pymelEnums': {}},
  'MRichSelection': {'enums': {},
                     'invertibles': [('setSelection', 'getSelection')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'clear': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nThis method empties the rich selection.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'getSelection': [{'argInfo': {'selection': {'doc': 'Storage for the selection list',
                                                                             'type': 'MSelectionList'}},
                                                   'args': [('selection',
                                                             'MSelectionList',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns a copy of the non-symmetry component of the rich selection.',
                                                   'inArgs': [],
                                                   'inverse': ('setSelection',
                                                               False),
                                                   'outArgs': ['selection'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'selection': ['&']},
                                                   'types': {'selection': 'MSelectionList'}}],
                                 'getSymmetry': [{'argInfo': {'symmetry': {'doc': 'Storage for the symmetric selection list',
                                                                           'type': 'MSelectionList'}},
                                                  'args': [('symmetry',
                                                            'MSelectionList',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns a copy of the symmetry component of the rich selection.',
                                                  'inArgs': [],
                                                  'outArgs': ['symmetry'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'symmetry': ['&']},
                                                  'types': {'symmetry': 'MSelectionList'}}],
                                 'getSymmetryMatrix': [{'argInfo': {'space': {'doc': 'The transformation space of the symmetryMatrix',
                                                                              'type': ('MSpace',
                                                                                       'Space')},
                                                                    'symmetryMatrix': {'doc': 'Storage for the symmetry matrix ',
                                                                                       'type': 'MMatrix'}},
                                                        'args': [('symmetryMatrix',
                                                                  'MMatrix',
                                                                  'out'),
                                                                 ('space',
                                                                  ('MSpace',
                                                                   'Space'),
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturns the raw symmetry matrix to use for the symmetric components of the rich selection. The caller is responsible for handling any necessary transformation space conversions when using this version of getSymmetryMatrix.',
                                                        'inArgs': [],
                                                        'outArgs': ['symmetryMatrix',
                                                                    'space'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'space': ['&'],
                                                                           'symmetryMatrix': ['&']},
                                                        'types': {'space': ('MSpace',
                                                                            'Space'),
                                                                  'symmetryMatrix': 'MMatrix'}},
                                                       {'argInfo': {'path': {'doc': 'The DAG path the matrix should be calculated for ',
                                                                             'type': 'MDagPath'},
                                                                    'space': {'doc': 'The space the matrix should be calculated in. Only kWorld and kObject are currently supported. ',
                                                                              'type': ('MSpace',
                                                                                       'Space')},
                                                                    'symmetryMatrix': {'doc': 'Storage for the symmetry matrix',
                                                                                       'type': 'MMatrix'}},
                                                        'args': [('path',
                                                                  'MDagPath',
                                                                  'in'),
                                                                 ('space',
                                                                  ('MSpace',
                                                                   'Space'),
                                                                  'in'),
                                                                 ('symmetryMatrix',
                                                                  'MMatrix',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nReturns the symmetry matrix to use for the symmetric component of the specified DAG object. This method handles any matrix space conversions for you.',
                                                        'inArgs': ['path',
                                                                   'space'],
                                                        'outArgs': ['symmetryMatrix'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'path': ['const',
                                                                                    '&'],
                                                                           'space': [],
                                                                           'symmetryMatrix': ['&']},
                                                        'types': {'path': 'MDagPath',
                                                                  'space': ('MSpace',
                                                                            'Space'),
                                                                  'symmetryMatrix': 'MMatrix'}}],
                                 'getSymmetryPlane': [{'argInfo': {'path': {'doc': 'The DAG path the plane should be calculated for ',
                                                                            'type': 'MDagPath'},
                                                                   'space': {'doc': 'The space the plane should be calculated in. Only kWorld and kObject are currently supported. ',
                                                                             'type': ('MSpace',
                                                                                      'Space')},
                                                                   'symmetryPlane': {'doc': 'Storage for the symmetry plane',
                                                                                     'type': 'MPlane'}},
                                                       'args': [('path',
                                                                 'MDagPath',
                                                                 'in'),
                                                                ('space',
                                                                 ('MSpace',
                                                                  'Space'),
                                                                 'in'),
                                                                ('symmetryPlane',
                                                                 'MPlane',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the plane of symmetry. This can be used to enforce seam weights in tools that support symmetry. Note that the direction of the plane carries no significance (specifically, having a positive offset from the plane does not imply a point is part of the non-symmetric selection).',
                                                       'inArgs': ['path',
                                                                  'space'],
                                                       'outArgs': ['symmetryPlane'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'path': ['const',
                                                                                   '&'],
                                                                          'space': [],
                                                                          'symmetryPlane': ['&']},
                                                       'types': {'path': 'MDagPath',
                                                                 'space': ('MSpace',
                                                                           'Space'),
                                                                 'symmetryPlane': 'MPlane'}}],
                                 'setSelection': [{'argInfo': {'selection': {'doc': 'The selection list',
                                                                             'type': 'MSelectionList'}},
                                                   'args': [('selection',
                                                             'MSelectionList',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the non-symmetry component of the rich selection.',
                                                   'inArgs': ['selection'],
                                                   'inverse': ('getSelection',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'selection': ['const',
                                                                                    '&']},
                                                   'types': {'selection': 'MSelectionList'}}]},
                     'pymelEnums': {}},
  'MSceneMessage': {'enums': {'Message': {'valueDocs': {'afterCreateReference': 'Called after a File > CreateReference operation.',
                                                        'afterCreateReferenceAndRecordEdits': 'Same as kAfterCreateReference except reference edits are recorded during the execution of the callback.',
                                                        'afterExport': 'Called after a File > Export operation.',
                                                        'afterExportReference': 'Called after a File > ExportReference operation.',
                                                        'afterFileRead': 'Called immediately after any file read operation (open, import or reference) and while reading state (',
                                                        'afterImport': 'Called after a File > Import operation.',
                                                        'afterImportReference': 'Called after a File > ImportReference operation.',
                                                        'afterLoadReference': 'Called after a File > LoadReference operation.',
                                                        'afterLoadReferenceAndRecordEdits': 'Same as kAfterLoadReference except reference edits are recorded during the execution of the callback.',
                                                        'afterNew': 'Called after a File > New operation.',
                                                        'afterOpen': 'Called after a File > Open operation.',
                                                        'afterPluginLoad': 'Called after a plugin is loaded.',
                                                        'afterPluginUnload': 'Called after a plugin is unloaded.',
                                                        'afterReference': 'Called after a File > Reference operation. Deprecated. Use kAfterCreateReference/kAfterLoadReference.',
                                                        'afterRemoveReference': 'Called after a File > RemoveReference operation.',
                                                        'afterSave': 'Called after a File > Save (or SaveAs) operation.',
                                                        'afterSceneReadAndRecordEdits': 'Call once after any file operation (open, import or reference) with reference edits recorded during the execution of the callback Note, isReadingFile is false during this callback.',
                                                        'afterSoftwareFrameRender': 'Called after each frame of a Software Render.',
                                                        'afterSoftwareRender': 'Called after a Software Render ends.',
                                                        'afterUnloadReference': 'Called after a File > UnloadReference operation.',
                                                        'beforeCreateReference': 'Called before a File > CreateReference operation.',
                                                        'beforeCreateReferenceAndRecordEdits': 'Same as kBeforeCreateReference except reference edits are recorded during the execution of the callback.',
                                                        'beforeCreateReferenceCheck': 'Called prior to a File > CreateReference operation, allows user to cancel action.',
                                                        'beforeExport': 'Called before a File > Export operation.',
                                                        'beforeExportCheck': 'Called prior to File > Export operation, allows user to cancel action.',
                                                        'beforeExportReference': 'Called before a File > ExportReference operation.',
                                                        'beforeFileRead': 'Called immediately before any file read operation (open, import or reference) and while reading state (',
                                                        'beforeImport': 'Called before a File > Import operation.',
                                                        'beforeImportCheck': 'Called prior to File > Import operation, allows user to cancel action.',
                                                        'beforeImportReference': 'Called before a File > ImportReference operation.',
                                                        'beforeLoadReference': 'Called before a File > LoadReference operation.',
                                                        'beforeLoadReferenceAndRecordEdits': 'Same as kBeforeLoadReference except reference edits are recorded during the execution of the callback.',
                                                        'beforeLoadReferenceCheck': 'Called before a File > LoadReference operation, allows user to cancel action.',
                                                        'beforeNew': 'Called before a File > New operation.',
                                                        'beforeNewCheck': 'Called prior to File > New operation, allows user to cancel action.',
                                                        'beforeOpen': 'Called before a File > Open operation.',
                                                        'beforeOpenCheck': 'Called prior to File > Open operation, allows user to cancel action.',
                                                        'beforePluginLoad': 'Called prior to a plugin being loaded.',
                                                        'beforePluginUnload': 'Called prior to a plugin being unloaded.',
                                                        'beforeReference': 'Called before a File > Reference operation. Deprecated. Use kBeforeCreateReference/kBeforeLoadReference.',
                                                        'beforeReferenceCheck': 'Called prior to a File > CreateReference operation, allows user to cancel action. Deprecated. Use kBeforeCreateReferenceCheck.',
                                                        'beforeRemoveReference': 'Called before a File > RemoveReference operation.',
                                                        'beforeSave': 'Called before a File > Save (or SaveAs) operation.',
                                                        'beforeSaveCheck': 'Called prior to File > Save operation, allows user to cancel action.',
                                                        'beforeSoftwareFrameRender': 'Called before each frame of a Software Render.',
                                                        'beforeSoftwareRender': 'Called before a Software Render begins.',
                                                        'beforeUnloadReference': 'Called before a File > UnloadReference operation.',
                                                        'exportStarted': 'Called at the start of a File > Export operation, after the export file has become the active file.',
                                                        'kAfterCreateReference': 'Called after a File > CreateReference operation.',
                                                        'kAfterCreateReferenceAndRecordEdits': 'Same as kAfterCreateReference except reference edits are recorded during the execution of the callback.',
                                                        'kAfterExport': 'Called after a File > Export operation.',
                                                        'kAfterExportReference': 'Called after a File > ExportReference operation.',
                                                        'kAfterFileRead': 'Called immediately after any file read operation (open, import or reference) and while reading state (',
                                                        'kAfterImport': 'Called after a File > Import operation.',
                                                        'kAfterImportReference': 'Called after a File > ImportReference operation.',
                                                        'kAfterLoadReference': 'Called after a File > LoadReference operation.',
                                                        'kAfterLoadReferenceAndRecordEdits': 'Same as kAfterLoadReference except reference edits are recorded during the execution of the callback.',
                                                        'kAfterNew': 'Called after a File > New operation.',
                                                        'kAfterOpen': 'Called after a File > Open operation.',
                                                        'kAfterPluginLoad': 'Called after a plugin is loaded.',
                                                        'kAfterPluginUnload': 'Called after a plugin is unloaded.',
                                                        'kAfterReference': 'Called after a File > Reference operation. Deprecated. Use kAfterCreateReference/kAfterLoadReference.',
                                                        'kAfterRemoveReference': 'Called after a File > RemoveReference operation.',
                                                        'kAfterSave': 'Called after a File > Save (or SaveAs) operation.',
                                                        'kAfterSceneReadAndRecordEdits': 'Call once after any file operation (open, import or reference) with reference edits recorded during the execution of the callback Note, isReadingFile is false during this callback.',
                                                        'kAfterSoftwareFrameRender': 'Called after each frame of a Software Render.',
                                                        'kAfterSoftwareRender': 'Called after a Software Render ends.',
                                                        'kAfterUnloadReference': 'Called after a File > UnloadReference operation.',
                                                        'kBeforeCreateReference': 'Called before a File > CreateReference operation.',
                                                        'kBeforeCreateReferenceAndRecordEdits': 'Same as kBeforeCreateReference except reference edits are recorded during the execution of the callback.',
                                                        'kBeforeCreateReferenceCheck': 'Called prior to a File > CreateReference operation, allows user to cancel action.',
                                                        'kBeforeExport': 'Called before a File > Export operation.',
                                                        'kBeforeExportCheck': 'Called prior to File > Export operation, allows user to cancel action.',
                                                        'kBeforeExportReference': 'Called before a File > ExportReference operation.',
                                                        'kBeforeFileRead': 'Called immediately before any file read operation (open, import or reference) and while reading state (',
                                                        'kBeforeImport': 'Called before a File > Import operation.',
                                                        'kBeforeImportCheck': 'Called prior to File > Import operation, allows user to cancel action.',
                                                        'kBeforeImportReference': 'Called before a File > ImportReference operation.',
                                                        'kBeforeLoadReference': 'Called before a File > LoadReference operation.',
                                                        'kBeforeLoadReferenceAndRecordEdits': 'Same as kBeforeLoadReference except reference edits are recorded during the execution of the callback.',
                                                        'kBeforeLoadReferenceCheck': 'Called before a File > LoadReference operation, allows user to cancel action.',
                                                        'kBeforeNew': 'Called before a File > New operation.',
                                                        'kBeforeNewCheck': 'Called prior to File > New operation, allows user to cancel action.',
                                                        'kBeforeOpen': 'Called before a File > Open operation.',
                                                        'kBeforeOpenCheck': 'Called prior to File > Open operation, allows user to cancel action.',
                                                        'kBeforePluginLoad': 'Called prior to a plugin being loaded.',
                                                        'kBeforePluginUnload': 'Called prior to a plugin being unloaded.',
                                                        'kBeforeReference': 'Called before a File > Reference operation. Deprecated. Use kBeforeCreateReference/kBeforeLoadReference.',
                                                        'kBeforeReferenceCheck': 'Called prior to a File > CreateReference operation, allows user to cancel action. Deprecated. Use kBeforeCreateReferenceCheck.',
                                                        'kBeforeRemoveReference': 'Called before a File > RemoveReference operation.',
                                                        'kBeforeSave': 'Called before a File > Save (or SaveAs) operation.',
                                                        'kBeforeSaveCheck': 'Called prior to File > Save operation, allows user to cancel action.',
                                                        'kBeforeSoftwareFrameRender': 'Called before each frame of a Software Render.',
                                                        'kBeforeSoftwareRender': 'Called before a Software Render begins.',
                                                        'kBeforeUnloadReference': 'Called before a File > UnloadReference operation.',
                                                        'kExportStarted': 'Called at the start of a File > Export operation, after the export file has become the active file.',
                                                        'kLast': 'Last value of the enum.',
                                                        'kMayaExiting': 'Called just before Maya exits.',
                                                        'kMayaInitialized': 'Called on interactive or batch startup after initialization.',
                                                        'kSceneUpdate': 'Called after any operation that changes which files are loaded.',
                                                        'kSoftwareRenderInterrupted': 'Called when an interactive render is interrupted by the user.',
                                                        'last': 'Last value of the enum.',
                                                        'mayaExiting': 'Called just before Maya exits.',
                                                        'mayaInitialized': 'Called on interactive or batch startup after initialization.',
                                                        'sceneUpdate': 'Called after any operation that changes which files are loaded.',
                                                        'softwareRenderInterrupted': 'Called when an interactive render is interrupted by the user.'},
                                          'values': "Enum('Message', [('kSceneUpdate', 0), ('kBeforeNew', 1), ('kAfterNew', 2), ('kBeforeImport', 3), ('kAfterImport', 4), ('kBeforeOpen', 5), ('kAfterOpen', 6), ('kBeforeFileRead', 7), ('kAfterFileRead', 8), ('kAfterSceneReadAndRecordEdits', 9), ('kBeforeExport', 10), ('kAfterExport', 11), ('kBeforeSave', 12), ('kAfterSave', 13), ('kBeforeReference', 14), ('kAfterReference', 15), ('kBeforeRemoveReference', 16), ('kAfterRemoveReference', 17), ('kBeforeImportReference', 18), ('kAfterImportReference', 19), ('kBeforeExportReference', 20), ('kAfterExportReference', 21), ('kBeforeUnloadReference', 22), ('kAfterUnloadReference', 23), ('kBeforeSoftwareRender', 24), ('kAfterSoftwareRender', 25), ('kBeforeSoftwareFrameRender', 26), ('kAfterSoftwareFrameRender', 27), ('kSoftwareRenderInterrupted', 28), ('kMayaInitialized', 29), ('kMayaExiting', 30), ('kBeforeNewCheck', 31), ('kBeforeOpenCheck', 32), ('kBeforeSaveCheck', 33), ('kBeforeImportCheck', 34), ('kBeforeExportCheck', 35), ('kBeforeLoadReference', 36), ('kAfterLoadReference', 37), ('kBeforeLoadReferenceCheck', 38), ('kBeforeReferenceCheck', 39), ('kBeforeCreateReferenceCheck', 39), ('kBeforePluginLoad', 40), ('kAfterPluginLoad', 41), ('kBeforePluginUnload', 42), ('kAfterPluginUnload', 43), ('kBeforeCreateReference', 44), ('kAfterCreateReference', 45), ('kExportStarted', 46), ('kBeforeLoadReferenceAndRecordEdits', 47), ('kAfterLoadReferenceAndRecordEdits', 48), ('kBeforeCreateReferenceAndRecordEdits', 49), ('kAfterCreateReferenceAndRecordEdits', 50), ('kLast', 51)], multiKeys=True)"}},
                    'methods': {'addCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                            'type': 'void'},
                                                             'func': {'doc': 'the callback function  clientData User defined data passed to the callback function   ',
                                                                      'type': ('MMessage',
                                                                               'MBasicFunction')},
                                                             'msg': {'doc': 'the scene message that will trigger the callback ',
                                                                     'type': ('MSceneMessage',
                                                                              'Message')}},
                                                 'args': [('msg',
                                                           ('MSceneMessage',
                                                            'Message'),
                                                           'in'),
                                                          ('func',
                                                           ('MMessage',
                                                            'MBasicFunction'),
                                                           'in'),
                                                          ('clientData',
                                                           'void',
                                                           'in')],
                                                 'defaults': {'clientData': None},
                                                 'deprecated': False,
                                                 'doc': '\r\nAdds a new callback for the specified scene message.',
                                                 'inArgs': ['msg',
                                                            'func',
                                                            'clientData'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                'qualifiers': [],
                                                                'type': 'MCallbackId'},
                                                 'returnType': 'MCallbackId',
                                                 'static': True,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'clientData': ['*'],
                                                                    'func': [],
                                                                    'msg': []},
                                                 'types': {'clientData': 'void',
                                                           'func': ('MMessage',
                                                                    'MBasicFunction'),
                                                           'msg': ('MSceneMessage',
                                                                   'Message')}}],
                                'addCheckCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                 'type': 'void'},
                                                                  'func': {'doc': 'the callback function  retCode boolean passed in to the callback function. In case of error, the callback function should set this to false.  clientData User defined data passed to the callback function   ',
                                                                           'type': ('MMessage',
                                                                                    'MCheckFunction')},
                                                                  'msg': {'doc': 'the scene message that will trigger the callback ',
                                                                          'type': ('MSceneMessage',
                                                                                   'Message')}},
                                                      'args': [('msg',
                                                                ('MSceneMessage',
                                                                 'Message'),
                                                                'in'),
                                                               ('func',
                                                                ('MMessage',
                                                                 'MCheckFunction'),
                                                                'in'),
                                                               ('clientData',
                                                                'void',
                                                                'in')],
                                                      'defaults': {'clientData': None},
                                                      'deprecated': False,
                                                      'doc': "\r\nThis function adds a new callback for the specified scene message. The callback will have the ability to abort the current operation by returning false through its 'retCode' parameter.",
                                                      'inArgs': ['msg',
                                                                 'func',
                                                                 'clientData'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                     'qualifiers': [],
                                                                     'type': 'MCallbackId'},
                                                      'returnType': 'MCallbackId',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'clientData': ['*'],
                                                                         'func': [],
                                                                         'msg': []},
                                                      'types': {'clientData': 'void',
                                                                'func': ('MMessage',
                                                                         'MCheckFunction'),
                                                                'msg': ('MSceneMessage',
                                                                        'Message')}}],
                                'addCheckFileCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                     'type': 'void'},
                                                                      'func': {'doc': 'the callback function  retCode boolean passed in to the callback function. In case of error, the callback function should set this to false.  file MFileObject passed in to the callback function. This is the MFileObject that will be acted on by the current file IO operation, any modifications to it will be passed back to Maya and change the file being acted on.  clientData User defined data passed to the callback function   ',
                                                                               'type': ('MMessage',
                                                                                        'MCheckFileFunction')},
                                                                      'msg': {'doc': 'the scene message that will trigger the callback ',
                                                                              'type': ('MSceneMessage',
                                                                                       'Message')}},
                                                          'args': [('msg',
                                                                    ('MSceneMessage',
                                                                     'Message'),
                                                                    'in'),
                                                                   ('func',
                                                                    ('MMessage',
                                                                     'MCheckFileFunction'),
                                                                    'in'),
                                                                   ('clientData',
                                                                    'void',
                                                                    'in')],
                                                          'defaults': {'clientData': None},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis function adds a new callback for the specified scene message. This callback has the option to abort the current operation by setting the retCode parameter to false. The file parameter stores the target file for the current file IO operation, by modifying this file parameter the target file will be changed as well.',
                                                          'inArgs': ['msg',
                                                                     'func',
                                                                     'clientData'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                         'qualifiers': [],
                                                                         'type': 'MCallbackId'},
                                                          'returnType': 'MCallbackId',
                                                          'static': True,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'clientData': ['*'],
                                                                             'func': [],
                                                                             'msg': []},
                                                          'types': {'clientData': 'void',
                                                                    'func': ('MMessage',
                                                                             'MCheckFileFunction'),
                                                                    'msg': ('MSceneMessage',
                                                                            'Message')}}],
                                'addCheckReferenceCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                          'type': 'void'},
                                                                           'func': {'doc': 'the callback function  retCode boolean passed in to the callback function. In case of error, the callback function should set this to false.  referenceNode The reference node.  file The resolved file path of the referenced file.  clientData User defined data passed to the callback function   ',
                                                                                    'type': ('MMessage',
                                                                                             'MCheckObjectFileFunction')},
                                                                           'msg': {'doc': 'the scene message that will trigger the callback ',
                                                                                   'type': ('MSceneMessage',
                                                                                            'Message')}},
                                                               'args': [('msg',
                                                                         ('MSceneMessage',
                                                                          'Message'),
                                                                         'in'),
                                                                        ('func',
                                                                         ('MMessage',
                                                                          'MCheckObjectFileFunction'),
                                                                         'in'),
                                                                        ('clientData',
                                                                         'void',
                                                                         'in')],
                                                               'defaults': {'clientData': None},
                                                               'deprecated': False,
                                                               'doc': "\r\nThis function adds a new callback for the specified scene message. The callback will have the ability to abort the current operation by returning false through its 'retCode' parameter.",
                                                               'inArgs': ['msg',
                                                                          'func',
                                                                          'clientData'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                              'qualifiers': [],
                                                                              'type': 'MCallbackId'},
                                                               'returnType': 'MCallbackId',
                                                               'static': True,
                                                               'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                  'clientData': ['*'],
                                                                                  'func': [],
                                                                                  'msg': []},
                                                               'types': {'clientData': 'void',
                                                                         'func': ('MMessage',
                                                                                  'MCheckObjectFileFunction'),
                                                                         'msg': ('MSceneMessage',
                                                                                 'Message')}}],
                                'addConnectionFailedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                            'type': 'void'},
                                                                             'func': {'doc': 'the callback function  srcPlug Source plug of the connection (or a NULL plug if it could not be found)  destPlug Destination plug of the connection (or a NULL plug if it could not be found)  srcPlugName Name used to look up the source plug.  dstPlugName Name used to look up the destination plug.  clientData User defined data passed to the callback function   ',
                                                                                      'type': ('MMessage',
                                                                                               'MConnFailFunction')}},
                                                                 'args': [('func',
                                                                           ('MMessage',
                                                                            'MConnFailFunction'),
                                                                           'in'),
                                                                          ('clientData',
                                                                           'void',
                                                                           'in')],
                                                                 'defaults': {'clientData': None},
                                                                 'deprecated': False,
                                                                 'doc': "\r\nThis method registers a callback that is called when a connection was unable to be made. Currently, the callback is only triggered during the reading of files (.ma or .mb) or of edits files (.editMA or .editMB files created by Maya's offline file support). The most common reasons why a connection would fail are:  \n inability to find the specified node or attribute names, or  \n a conflicting existing connection \n \n Parameters: \n \n [in]  func  the callback function  \n srcPlug  Source plug of the connection (or a NULL plug if it could not be found)  \n destPlug  Destination plug of the connection (or a NULL plug if it could not be found)  \n srcPlugName  Name used to look up the source plug.  \n dstPlugName  Name used to look up the destination plug.  \n clientData  User defined data passed to the callback function  \n \n \n [in]  clientData  User defined data passed to the callback function  \n [out]  ReturnStatus  status code \n \n \n Returns: Identifier used for removing the callback. \n Status Codes: \n MS::kSuccess  Operation succeeded  \n MS::kInsufficientMemory  No memory available  \n MS::kFailure  Error adding callback  \n \n \n",
                                                                 'inArgs': ['func',
                                                                            'clientData'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                'qualifiers': [],
                                                                                'type': 'MCallbackId'},
                                                                 'returnType': 'MCallbackId',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'clientData': ['*'],
                                                                                    'func': []},
                                                                 'types': {'clientData': 'void',
                                                                           'func': ('MMessage',
                                                                                    'MConnFailFunction')}}],
                                'addNamespaceRenamedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data passed to the callback function ',
                                                                                            'type': 'void'},
                                                                             'func': {'doc': 'the callback function  nsNew New name of namespace that was changed  nsOld Old name of namespace that was changed  clientData User defined data passed to the callback function   ',
                                                                                      'type': ('MMessage',
                                                                                               'MTwoStringFunction')}},
                                                                 'args': [('func',
                                                                           ('MMessage',
                                                                            'MTwoStringFunction'),
                                                                           'in'),
                                                                          ('clientData',
                                                                           'void',
                                                                           'in')],
                                                                 'defaults': {'clientData': None},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nThis method registers a callback that is called when a namespace is renamed.',
                                                                 'inArgs': ['func',
                                                                            'clientData'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                'qualifiers': [],
                                                                                'type': 'MCallbackId'},
                                                                 'returnType': 'MCallbackId',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'clientData': ['*'],
                                                                                    'func': []},
                                                                 'types': {'clientData': 'void',
                                                                           'func': ('MMessage',
                                                                                    'MTwoStringFunction')}}],
                                'addReferenceCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                     'type': 'void'},
                                                                      'func': {'doc': 'the callback function  referenceNode The reference node.  file The resolved file path of the referenced file.  clientData User defined data passed to the callback function   ',
                                                                               'type': ('MMessage',
                                                                                        'MObjectFileFunction')},
                                                                      'msg': {'doc': 'the scene message that will trigger the callback ',
                                                                              'type': ('MSceneMessage',
                                                                                       'Message')}},
                                                          'args': [('msg',
                                                                    ('MSceneMessage',
                                                                     'Message'),
                                                                    'in'),
                                                                   ('func',
                                                                    ('MMessage',
                                                                     'MObjectFileFunction'),
                                                                    'in'),
                                                                   ('clientData',
                                                                    'void',
                                                                    'in')],
                                                          'defaults': {'clientData': None},
                                                          'deprecated': False,
                                                          'doc': '\r\nThis function adds a new callback for the specified scene message.',
                                                          'inArgs': ['msg',
                                                                     'func',
                                                                     'clientData'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                         'qualifiers': [],
                                                                         'type': 'MCallbackId'},
                                                          'returnType': 'MCallbackId',
                                                          'static': True,
                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                             'clientData': ['*'],
                                                                             'func': [],
                                                                             'msg': []},
                                                          'types': {'clientData': 'void',
                                                                    'func': ('MMessage',
                                                                             'MObjectFileFunction'),
                                                                    'msg': ('MSceneMessage',
                                                                            'Message')}}],
                                'addStringArrayCallback': [{'argInfo': {'clientData': {'doc': 'user data that will be passed to the callback function ',
                                                                                       'type': 'void'},
                                                                        'func': {'doc': 'the callback function  strs immutable array of strings  clientData User defined data passed to the callback function   ',
                                                                                 'type': ('MMessage',
                                                                                          'MStringArrayFunction')},
                                                                        'msg': {'doc': 'the scene message that will trigger the callback ',
                                                                                'type': ('MSceneMessage',
                                                                                         'Message')}},
                                                            'args': [('msg',
                                                                      ('MSceneMessage',
                                                                       'Message'),
                                                                      'in'),
                                                                     ('func',
                                                                      ('MMessage',
                                                                       'MStringArrayFunction'),
                                                                      'in'),
                                                                     ('clientData',
                                                                      'void',
                                                                      'in')],
                                                            'defaults': {'clientData': None},
                                                            'deprecated': False,
                                                            'doc': '\r\nAdds a new callback which takes a string array argument, in addition to the usual clientData.',
                                                            'inArgs': ['msg',
                                                                       'func',
                                                                       'clientData'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                           'qualifiers': [],
                                                                           'type': 'MCallbackId'},
                                                            'returnType': 'MCallbackId',
                                                            'static': True,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'clientData': ['*'],
                                                                               'func': [],
                                                                               'msg': []},
                                                            'types': {'clientData': 'void',
                                                                      'func': ('MMessage',
                                                                               'MStringArrayFunction'),
                                                                      'msg': ('MSceneMessage',
                                                                              'Message')}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                    'pymelEnums': {'Message': "Enum('Message', [('sceneUpdate', 0), ('kSceneUpdate', 0), ('beforeNew', 1), ('kBeforeNew', 1), ('afterNew', 2), ('kAfterNew', 2), ('beforeImport', 3), ('kBeforeImport', 3), ('afterImport', 4), ('kAfterImport', 4), ('beforeOpen', 5), ('kBeforeOpen', 5), ('afterOpen', 6), ('kAfterOpen', 6), ('beforeFileRead', 7), ('kBeforeFileRead', 7), ('afterFileRead', 8), ('kAfterFileRead', 8), ('afterSceneReadAndRecordEdits', 9), ('kAfterSceneReadAndRecordEdits', 9), ('beforeExport', 10), ('kBeforeExport', 10), ('afterExport', 11), ('kAfterExport', 11), ('beforeSave', 12), ('kBeforeSave', 12), ('afterSave', 13), ('kAfterSave', 13), ('beforeReference', 14), ('kBeforeReference', 14), ('afterReference', 15), ('kAfterReference', 15), ('beforeRemoveReference', 16), ('kBeforeRemoveReference', 16), ('afterRemoveReference', 17), ('kAfterRemoveReference', 17), ('beforeImportReference', 18), ('kBeforeImportReference', 18), ('afterImportReference', 19), ('kAfterImportReference', 19), ('beforeExportReference', 20), ('kBeforeExportReference', 20), ('afterExportReference', 21), ('kAfterExportReference', 21), ('beforeUnloadReference', 22), ('kBeforeUnloadReference', 22), ('afterUnloadReference', 23), ('kAfterUnloadReference', 23), ('beforeSoftwareRender', 24), ('kBeforeSoftwareRender', 24), ('afterSoftwareRender', 25), ('kAfterSoftwareRender', 25), ('beforeSoftwareFrameRender', 26), ('kBeforeSoftwareFrameRender', 26), ('afterSoftwareFrameRender', 27), ('kAfterSoftwareFrameRender', 27), ('softwareRenderInterrupted', 28), ('kSoftwareRenderInterrupted', 28), ('mayaInitialized', 29), ('kMayaInitialized', 29), ('mayaExiting', 30), ('kMayaExiting', 30), ('beforeNewCheck', 31), ('kBeforeNewCheck', 31), ('beforeOpenCheck', 32), ('kBeforeOpenCheck', 32), ('beforeSaveCheck', 33), ('kBeforeSaveCheck', 33), ('beforeImportCheck', 34), ('kBeforeImportCheck', 34), ('beforeExportCheck', 35), ('kBeforeExportCheck', 35), ('beforeLoadReference', 36), ('kBeforeLoadReference', 36), ('afterLoadReference', 37), ('kAfterLoadReference', 37), ('beforeLoadReferenceCheck', 38), ('kBeforeLoadReferenceCheck', 38), ('beforeReferenceCheck', 39), ('beforeCreateReferenceCheck', 39), ('kBeforeCreateReferenceCheck', 39), ('kBeforeReferenceCheck', 39), ('beforePluginLoad', 40), ('kBeforePluginLoad', 40), ('afterPluginLoad', 41), ('kAfterPluginLoad', 41), ('beforePluginUnload', 42), ('kBeforePluginUnload', 42), ('afterPluginUnload', 43), ('kAfterPluginUnload', 43), ('beforeCreateReference', 44), ('kBeforeCreateReference', 44), ('afterCreateReference', 45), ('kAfterCreateReference', 45), ('exportStarted', 46), ('kExportStarted', 46), ('beforeLoadReferenceAndRecordEdits', 47), ('kBeforeLoadReferenceAndRecordEdits', 47), ('afterLoadReferenceAndRecordEdits', 48), ('kAfterLoadReferenceAndRecordEdits', 48), ('beforeCreateReferenceAndRecordEdits', 49), ('kBeforeCreateReferenceAndRecordEdits', 49), ('afterCreateReferenceAndRecordEdits', 50), ('kAfterCreateReferenceAndRecordEdits', 50), ('last', 51), ('kLast', 51)], multiKeys=True)"}},
  'MScriptUtil': {'enums': {},
                  'invertibles': [('setUint', 'getUint'),
                                  ('setShort2ArrayItem',
                                   'getShort2ArrayItem'),
                                  ('setDouble3ArrayItem',
                                   'getDouble3ArrayItem'),
                                  ('setFloat', 'getFloat'),
                                  ('setUchar', 'getUchar'),
                                  ('setDouble2ArrayItem',
                                   'getDouble2ArrayItem'),
                                  ('setBool', 'getBool'),
                                  ('setFloat2ArrayItem',
                                   'getFloat2ArrayItem'),
                                  ('setInt2ArrayItem', 'getInt2ArrayItem'),
                                  ('setInt3ArrayItem', 'getInt3ArrayItem'),
                                  ('setUint4ArrayItem',
                                   'getUint4ArrayItem'),
                                  ('setShort4ArrayItem',
                                   'getShort4ArrayItem'),
                                  ('setDouble4ArrayItem',
                                   'getDouble4ArrayItem'),
                                  ('setInt4ArrayItem', 'getInt4ArrayItem'),
                                  ('setInt', 'getInt'),
                                  ('setFloat3ArrayItem',
                                   'getFloat3ArrayItem'),
                                  ('setFloat4ArrayItem',
                                   'getFloat4ArrayItem'),
                                  ('setUint3ArrayItem',
                                   'getUint3ArrayItem'),
                                  ('setShort', 'getShort'),
                                  ('setDouble', 'getDouble'),
                                  ('setChar', 'getChar'),
                                  ('setUint2ArrayItem',
                                   'getUint2ArrayItem'),
                                  ('setShort3ArrayItem',
                                   'getShort3ArrayItem')],
                  'methods': {'asBool': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturn the first item added to this object as a bool. \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asBoolPtr': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturn a bool pointer to the data of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asCharPtr': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturn a char pointer to the data of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asDouble': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturn the first item added to this object as a double. \n',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asDouble2Ptr': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A pointer to an array of 2 double. ',
                                                               'qualifiers': ['*'],
                                                               'type': ('MScriptUtil',
                                                                        'Mdouble2')},
                                                'returnType': ('MScriptUtil',
                                                               'Mdouble2'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'asDouble3Ptr': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A pointer to an array of 3 double. ',
                                                               'qualifiers': ['*'],
                                                               'type': ('MScriptUtil',
                                                                        'Mdouble3')},
                                                'returnType': ('MScriptUtil',
                                                               'Mdouble3'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'asDouble4Ptr': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A pointer to an array of 4 double. ',
                                                               'qualifiers': ['*'],
                                                               'type': ('MScriptUtil',
                                                                        'Mdouble4')},
                                                'returnType': ('MScriptUtil',
                                                               'Mdouble4'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'asDoublePtr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturn a double pointer to the data of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'double'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'asFloat': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturn the first item added to this object as a float. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asFloat2Ptr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A pointer to an array of 2 float. ',
                                                              'qualifiers': ['*'],
                                                              'type': ('MScriptUtil',
                                                                       'Mfloat2')},
                                               'returnType': ('MScriptUtil',
                                                              'Mfloat2'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'asFloat3Ptr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A pointer to an array of 3 float. ',
                                                              'qualifiers': ['*'],
                                                              'type': ('MScriptUtil',
                                                                       'Mfloat3')},
                                               'returnType': ('MScriptUtil',
                                                              'Mfloat3'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'asFloat4Ptr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A pointer to an array of 4 float. ',
                                                              'qualifiers': ['*'],
                                                              'type': ('MScriptUtil',
                                                                       'Mfloat4')},
                                               'returnType': ('MScriptUtil',
                                                              'Mfloat4'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'asFloatPtr': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturn a float pointer to the data of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'float'},
                                              'returnType': 'float',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'asInt': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturn the first item added to this object as an integer. \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'asInt2Ptr': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A pointer to an array of 2 int. ',
                                                            'qualifiers': ['*'],
                                                            'type': ('MScriptUtil',
                                                                     'Mint2')},
                                             'returnType': ('MScriptUtil',
                                                            'Mint2'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asInt3Ptr': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A pointer to an array of 3 int. ',
                                                            'qualifiers': ['*'],
                                                            'type': ('MScriptUtil',
                                                                     'Mint3')},
                                             'returnType': ('MScriptUtil',
                                                            'Mint3'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asInt4Ptr': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A pointer to an array of 4 int. ',
                                                            'qualifiers': ['*'],
                                                            'type': ('MScriptUtil',
                                                                     'Mint4')},
                                             'returnType': ('MScriptUtil',
                                                            'Mint4'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asIntPtr': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturn an integer pointer to the data of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'asShort': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturn the first item added to this object as a short. \n',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'short'},
                                           'returnType': 'short',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asShort2Ptr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A pointer to an array of 2 short. ',
                                                              'qualifiers': ['*'],
                                                              'type': ('MScriptUtil',
                                                                       'Mshort2')},
                                               'returnType': ('MScriptUtil',
                                                              'Mshort2'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'asShort3Ptr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A pointer to an array of 3 short. ',
                                                              'qualifiers': ['*'],
                                                              'type': ('MScriptUtil',
                                                                       'Mshort3')},
                                               'returnType': ('MScriptUtil',
                                                              'Mshort3'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'asShort4Ptr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A pointer to an array of 4 short. ',
                                                              'qualifiers': ['*'],
                                                              'type': ('MScriptUtil',
                                                                       'Mshort4')},
                                               'returnType': ('MScriptUtil',
                                                              'Mshort4'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'asShortPtr': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturn a short pointer to the data of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'short'},
                                              'returnType': 'short',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'asUcharPtr': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturn a unsigned char pointer to the data of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'asUint': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nReturn the first item added to this object as a unsigned integer. \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'asUint2Ptr': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A pointer to an array of 2 unsigned int. ',
                                                             'qualifiers': ['*'],
                                                             'type': ('MScriptUtil',
                                                                      'Muint2')},
                                              'returnType': ('MScriptUtil',
                                                             'Muint2'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'asUint3Ptr': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A pointer to an array of 3 unsigned int. ',
                                                             'qualifiers': ['*'],
                                                             'type': ('MScriptUtil',
                                                                      'Muint3')},
                                              'returnType': ('MScriptUtil',
                                                             'Muint3'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'asUint4Ptr': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nCopy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A pointer to an array of 4 unsigned int. ',
                                                             'qualifiers': ['*'],
                                                             'type': ('MScriptUtil',
                                                                      'Muint4')},
                                              'returnType': ('MScriptUtil',
                                                             'Muint4'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'asUintPtr': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturn an unsigned integer pointer to the data of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'asUshortPtr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturn an unsigned short pointer to the data of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'short'},
                                               'returnType': 'short',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'createFloatArrayFromList': [{'argInfo': {'array': {'doc': 'Resulting array.',
                                                                                  'type': 'MFloatArray'},
                                                                        'pythonList': {'doc': 'Python list of 16 numeric values. ',
                                                                                       'type': 'void'}},
                                                            'args': [('pythonList',
                                                                      'void',
                                                                      'in'),
                                                                     ('array',
                                                                      'MFloatArray',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nCreate an  MFloatArray  object from a python list. The pythonList parameter must be a python list (1.0,2.0,...).',
                                                            'inArgs': ['pythonList'],
                                                            'outArgs': ['array'],
                                                            'returnInfo': {'doc': 'True if the conversion is successful, false otherwise. ',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': True,
                                                            'typeQualifiers': {'array': ['&'],
                                                                               'pythonList': ['*']},
                                                            'types': {'array': 'MFloatArray',
                                                                      'pythonList': 'void'}}],
                              'createFloatMatrixFromList': [{'argInfo': {'matrix': {'doc': 'Resulting matrix.',
                                                                                    'type': 'MFloatMatrix'},
                                                                         'pythonList': {'doc': 'Python list of 16 numeric values. ',
                                                                                        'type': 'void'}},
                                                             'args': [('pythonList',
                                                                       'void',
                                                                       'in'),
                                                                      ('matrix',
                                                                       'MFloatMatrix',
                                                                       'out')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nCreate an  MFloatMatrix  object from a list of 16 doubles. The pythonList parameter must be a python list (1.0,2.0,...).',
                                                             'inArgs': ['pythonList'],
                                                             'outArgs': ['matrix'],
                                                             'returnInfo': {'doc': 'True if the conversion is successful, false otherwise. ',
                                                                            'qualifiers': [],
                                                                            'type': 'bool'},
                                                             'returnType': 'bool',
                                                             'static': True,
                                                             'typeQualifiers': {'matrix': ['&'],
                                                                                'pythonList': ['*']},
                                                             'types': {'matrix': 'MFloatMatrix',
                                                                       'pythonList': 'void'}}],
                              'createFromDouble': [{'argInfo': {'w': {'doc': 'Fourth double value. ',
                                                                      'type': 'double'},
                                                                'x': {'doc': 'First double value. ',
                                                                      'type': 'double'},
                                                                'y': {'doc': 'Second double value. ',
                                                                      'type': 'double'},
                                                                'z': {'doc': 'Third double value. ',
                                                                      'type': 'double'}},
                                                    'args': [('x',
                                                              'double',
                                                              'in'),
                                                             ('y',
                                                              'double',
                                                              'in'),
                                                             ('z',
                                                              'double',
                                                              'in'),
                                                             ('w',
                                                              'double',
                                                              'in')],
                                                    'defaults': {'w': 0.0,
                                                                 'y': 0.0,
                                                                 'z': 0.0},
                                                    'deprecated': False,
                                                    'doc': '\nCreate this object from 4 doubles. Data already stored in this class will be cleared.',
                                                    'inArgs': ['x',
                                                               'y',
                                                               'z',
                                                               'w'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'w': [],
                                                                       'x': [],
                                                                       'y': [],
                                                                       'z': []},
                                                    'types': {'w': 'double',
                                                              'x': 'double',
                                                              'y': 'double',
                                                              'z': 'double'}}],
                              'createFromInt': [{'argInfo': {'w': {'doc': 'Fourth integer value. ',
                                                                   'type': 'int'},
                                                             'x': {'doc': 'First integer value. ',
                                                                   'type': 'int'},
                                                             'y': {'doc': 'Second integer value. ',
                                                                   'type': 'int'},
                                                             'z': {'doc': 'Third integer value. ',
                                                                   'type': 'int'}},
                                                 'args': [('x',
                                                           'int',
                                                           'in'),
                                                          ('y',
                                                           'int',
                                                           'in'),
                                                          ('z',
                                                           'int',
                                                           'in'),
                                                          ('w',
                                                           'int',
                                                           'in')],
                                                 'defaults': {'w': 0,
                                                              'y': 0,
                                                              'z': 0},
                                                 'deprecated': False,
                                                 'doc': '\nCreate this object from 4 integers. Data already stored in this class will be cleared.',
                                                 'inArgs': ['x',
                                                            'y',
                                                            'z',
                                                            'w'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'w': [],
                                                                    'x': [],
                                                                    'y': [],
                                                                    'z': []},
                                                 'types': {'w': 'int',
                                                           'x': 'int',
                                                           'y': 'int',
                                                           'z': 'int'}}],
                              'createFromList': [{'argInfo': {'length': {'doc': 'Number of elements in the list. ',
                                                                         'type': 'uint'},
                                                              'pythonList': {'doc': 'Python list of numeric values. ',
                                                                             'type': 'void'}},
                                                  'args': [('pythonList',
                                                            'void',
                                                            'in'),
                                                           ('length',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nCreate this object with a python list and length. For example: scriptUtil.createFromList( (1.0,3.0,5.0,7.0,8.0,10.0,33.0), 7 ) Data already stored in this class will be cleared.',
                                                  'inArgs': ['pythonList',
                                                             'length'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'length': ['unsigned'],
                                                                     'pythonList': ['*']},
                                                  'types': {'length': 'uint',
                                                            'pythonList': 'void'}}],
                              'createIntArrayFromList': [{'argInfo': {'array': {'doc': 'Resulting array.',
                                                                                'type': 'MIntArray'},
                                                                      'pythonList': {'doc': 'Python list of 16 numeric values. ',
                                                                                     'type': 'void'}},
                                                          'args': [('pythonList',
                                                                    'void',
                                                                    'in'),
                                                                   ('array',
                                                                    'MIntArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nCreate an  MIntArray  object from a python list. The pythonList parameter must be a python list (1.0,2.0,...).',
                                                          'inArgs': ['pythonList'],
                                                          'outArgs': ['array'],
                                                          'returnInfo': {'doc': 'True if the conversion is successful, false otherwise. ',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': True,
                                                          'typeQualifiers': {'array': ['&'],
                                                                             'pythonList': ['*']},
                                                          'types': {'array': 'MIntArray',
                                                                    'pythonList': 'void'}}],
                              'createMatrixFromList': [{'argInfo': {'matrix': {'doc': 'Resulting matrix.',
                                                                               'type': 'MMatrix'},
                                                                    'pythonList': {'doc': 'Python list of 16 numeric values. ',
                                                                                   'type': 'void'}},
                                                        'args': [('pythonList',
                                                                  'void',
                                                                  'in'),
                                                                 ('matrix',
                                                                  'MMatrix',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nCreate an  MMatrix  object from a list of 16 doubles. The pythonList parameter must be a python list (1.0,2.0,...).',
                                                        'inArgs': ['pythonList'],
                                                        'outArgs': ['matrix'],
                                                        'returnInfo': {'doc': 'True if the conversion is successful, false otherwise. ',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': True,
                                                        'typeQualifiers': {'matrix': ['&'],
                                                                           'pythonList': ['*']},
                                                        'types': {'matrix': 'MMatrix',
                                                                  'pythonList': 'void'}}],
                              'getBool': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                               'type': 'bool'}},
                                           'args': [('var',
                                                     'bool',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nGet the value of a bool reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                           'inArgs': ['var'],
                                           'inverse': ('setBool', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': True,
                                           'typeQualifiers': {'var': ['&']},
                                           'types': {'var': 'bool'}}],
                              'getBoolArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                          'type': 'uint'},
                                                                'var': {'doc': 'Array to read from. ',
                                                                        'type': 'bool'}},
                                                    'args': [('var',
                                                              'bool',
                                                              'in'),
                                                             ('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet a bool value from an array. Ensure that index is valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Value of the element. ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': True,
                                                    'typeQualifiers': {'index': ['unsigned'],
                                                                       'var': ['*']},
                                                    'types': {'index': 'uint',
                                                              'var': 'bool'}}],
                              'getChar': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                               'type': 'char'}},
                                           'args': [('var',
                                                     'char',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nGet the value of a char reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                           'inArgs': ['var'],
                                           'inverse': ('setChar', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': True,
                                           'typeQualifiers': {'var': ['&']},
                                           'types': {'var': 'char'}}],
                              'getCharArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                          'type': 'uint'},
                                                                'var': {'doc': 'Array to read from. ',
                                                                        'type': 'char'}},
                                                    'args': [('var',
                                                              'char',
                                                              'in'),
                                                             ('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet a char value from an array. Ensure that index is valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Value of the element. ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': True,
                                                    'typeQualifiers': {'index': ['unsigned'],
                                                                       'var': ['*']},
                                                    'types': {'index': 'uint',
                                                              'var': 'char'}}],
                              'getDouble': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                                 'type': 'double'}},
                                             'args': [('var',
                                                       'double',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nGet the value of a double reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                             'inArgs': [],
                                             'inverse': ('setDouble',
                                                         False),
                                             'outArgs': ['var'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': True,
                                             'typeQualifiers': {'var': ['&']},
                                             'types': {'var': 'double'}}],
                              'getDouble2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                         'type': 'uint'},
                                                                   'r': {'doc': 'First index in the array. ',
                                                                         'type': 'uint'},
                                                                   'var': {'doc': 'Array to read from. ',
                                                                           'type': 'double(*)__array2'}},
                                                       'args': [('var',
                                                                 'double(*)__array2',
                                                                 'in'),
                                                                ('r',
                                                                 'uint',
                                                                 'in'),
                                                                ('c',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nGet a value from the two dimensional array. Ensure that indicies are valid before calling this method.',
                                                       'inArgs': ['var',
                                                                  'r',
                                                                  'c'],
                                                       'inverse': ('setDouble2ArrayItem',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                      'qualifiers': [],
                                                                      'type': 'double'},
                                                       'returnType': 'double',
                                                       'static': True,
                                                       'typeQualifiers': {'c': ['unsigned'],
                                                                          'r': ['unsigned'],
                                                                          'var': []},
                                                       'types': {'c': 'uint',
                                                                 'r': 'uint',
                                                                 'var': 'double(*)__array2'}}],
                              'getDouble3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                         'type': 'uint'},
                                                                   'r': {'doc': 'First index in the array. ',
                                                                         'type': 'uint'},
                                                                   'var': {'doc': 'Array to read from. ',
                                                                           'type': 'double(*)__array3'}},
                                                       'args': [('var',
                                                                 'double(*)__array3',
                                                                 'in'),
                                                                ('r',
                                                                 'uint',
                                                                 'in'),
                                                                ('c',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nGet a value from the three dimensional array. Ensure that indicies are valid before calling this method.',
                                                       'inArgs': ['var',
                                                                  'r',
                                                                  'c'],
                                                       'inverse': ('setDouble3ArrayItem',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                      'qualifiers': [],
                                                                      'type': 'double'},
                                                       'returnType': 'double',
                                                       'static': True,
                                                       'typeQualifiers': {'c': ['unsigned'],
                                                                          'r': ['unsigned'],
                                                                          'var': []},
                                                       'types': {'c': 'uint',
                                                                 'r': 'uint',
                                                                 'var': 'double(*)__array3'}}],
                              'getDouble4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                         'type': 'uint'},
                                                                   'r': {'doc': 'First index in the array. ',
                                                                         'type': 'uint'},
                                                                   'var': {'doc': 'Array to read from. ',
                                                                           'type': 'double(*)__array4'}},
                                                       'args': [('var',
                                                                 'double(*)__array4',
                                                                 'in'),
                                                                ('r',
                                                                 'uint',
                                                                 'in'),
                                                                ('c',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nGet a value from the four dimensional array. Ensure that indicies are valid before calling this method.',
                                                       'inArgs': ['var',
                                                                  'r',
                                                                  'c'],
                                                       'inverse': ('setDouble4ArrayItem',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                      'qualifiers': [],
                                                                      'type': 'double'},
                                                       'returnType': 'double',
                                                       'static': True,
                                                       'typeQualifiers': {'c': ['unsigned'],
                                                                          'r': ['unsigned'],
                                                                          'var': []},
                                                       'types': {'c': 'uint',
                                                                 'r': 'uint',
                                                                 'var': 'double(*)__array4'}}],
                              'getDoubleArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                            'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'double'}},
                                                      'args': [('var',
                                                                'double',
                                                                'in'),
                                                               ('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet a double value from an array. Ensure that index is valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element. ',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': True,
                                                      'typeQualifiers': {'index': ['unsigned'],
                                                                         'var': ['*']},
                                                      'types': {'index': 'uint',
                                                                'var': 'double'}}],
                              'getFloat': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                                'type': 'float'}},
                                            'args': [('var',
                                                      'float',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nGet the values of a float reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                            'inArgs': [],
                                            'inverse': ('setFloat',
                                                        False),
                                            'outArgs': ['var'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': True,
                                            'typeQualifiers': {'var': ['&']},
                                            'types': {'var': 'float'}}],
                              'getFloat2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'float(*)__array2'}},
                                                      'args': [('var',
                                                                'float(*)__array2',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet a value from the two dimensional array. Ensure that indicies are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c'],
                                                      'inverse': ('setFloat2ArrayItem',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'var': 'float(*)__array2'}}],
                              'getFloat3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'float(*)__array3'}},
                                                      'args': [('var',
                                                                'float(*)__array3',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet a value from the three dimensional array. Ensure that indicies are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c'],
                                                      'inverse': ('setFloat3ArrayItem',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'var': 'float(*)__array3'}}],
                              'getFloat4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'float(*)__array4'}},
                                                      'args': [('var',
                                                                'float(*)__array4',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet a value from the four dimensional array. Ensure that indicies are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c'],
                                                      'inverse': ('setFloat4ArrayItem',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'var': 'float(*)__array4'}}],
                              'getFloatArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                           'type': 'uint'},
                                                                 'var': {'doc': 'Array to read from. ',
                                                                         'type': 'float'}},
                                                     'args': [('var',
                                                               'float',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nGet a float value from an array. Ensure that index is valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Value of the element. ',
                                                                    'qualifiers': [],
                                                                    'type': 'double'},
                                                     'returnType': 'double',
                                                     'static': True,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'var': ['*']},
                                                     'types': {'index': 'uint',
                                                               'var': 'float'}}],
                              'getInt': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                              'type': 'int'}},
                                          'args': [('var', 'int', 'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nGet the value of an integer reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                          'inArgs': [],
                                          'inverse': ('setInt', False),
                                          'outArgs': ['var'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': True,
                                          'typeQualifiers': {'var': ['&']},
                                          'types': {'var': 'int'}}],
                              'getInt2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                      'type': 'uint'},
                                                                'r': {'doc': 'First index in the array. ',
                                                                      'type': 'uint'},
                                                                'var': {'doc': 'Array to read from. ',
                                                                        'type': 'int(*)__array2'}},
                                                    'args': [('var',
                                                              'int(*)__array2',
                                                              'in'),
                                                             ('r',
                                                              'uint',
                                                              'in'),
                                                             ('c',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet a value from the two dimensional array. Ensure that indicies are valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'r',
                                                               'c'],
                                                    'inverse': ('setInt2ArrayItem',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': True,
                                                    'typeQualifiers': {'c': ['unsigned'],
                                                                       'r': ['unsigned'],
                                                                       'var': []},
                                                    'types': {'c': 'uint',
                                                              'r': 'uint',
                                                              'var': 'int(*)__array2'}}],
                              'getInt3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                      'type': 'uint'},
                                                                'r': {'doc': 'First index in the array. ',
                                                                      'type': 'uint'},
                                                                'var': {'doc': 'Array to read from. ',
                                                                        'type': 'int(*)__array3'}},
                                                    'args': [('var',
                                                              'int(*)__array3',
                                                              'in'),
                                                             ('r',
                                                              'uint',
                                                              'in'),
                                                             ('c',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet a value from the three dimensional array. Ensure that indicies are valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'r',
                                                               'c'],
                                                    'inverse': ('setInt3ArrayItem',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': True,
                                                    'typeQualifiers': {'c': ['unsigned'],
                                                                       'r': ['unsigned'],
                                                                       'var': []},
                                                    'types': {'c': 'uint',
                                                              'r': 'uint',
                                                              'var': 'int(*)__array3'}}],
                              'getInt4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                      'type': 'uint'},
                                                                'r': {'doc': 'First index in the array. ',
                                                                      'type': 'uint'},
                                                                'var': {'doc': 'Array to read from. ',
                                                                        'type': 'int(*)__array4'}},
                                                    'args': [('var',
                                                              'int(*)__array4',
                                                              'in'),
                                                             ('r',
                                                              'uint',
                                                              'in'),
                                                             ('c',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet a value from the four dimensional array. Ensure that indicies are valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'r',
                                                               'c'],
                                                    'inverse': ('setInt4ArrayItem',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': True,
                                                    'typeQualifiers': {'c': ['unsigned'],
                                                                       'r': ['unsigned'],
                                                                       'var': []},
                                                    'types': {'c': 'uint',
                                                              'r': 'uint',
                                                              'var': 'int(*)__array4'}}],
                              'getIntArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                         'type': 'uint'},
                                                               'var': {'doc': 'Array to read from. ',
                                                                       'type': 'int'}},
                                                   'args': [('var',
                                                             'int',
                                                             'in'),
                                                            ('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nGet a int value from an array. Ensure that index is valid before calling this method.',
                                                   'inArgs': ['var',
                                                              'index'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Value of the element. ',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': True,
                                                   'typeQualifiers': {'index': ['unsigned'],
                                                                      'var': ['*']},
                                                   'types': {'index': 'uint',
                                                             'var': 'int'}}],
                              'getShort': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                                'type': 'short'}},
                                            'args': [('var',
                                                      'short',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nGet the value of a short reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                            'inArgs': ['var'],
                                            'inverse': ('setShort',
                                                        False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': True,
                                            'typeQualifiers': {'var': ['&']},
                                            'types': {'var': 'short'}}],
                              'getShort2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'short(*)__array2'}},
                                                      'args': [('var',
                                                                'short(*)__array2',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet a value from the two dimensional array. Ensure that indicies are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c'],
                                                      'inverse': ('setShort2ArrayItem',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                     'qualifiers': [],
                                                                     'type': 'short'},
                                                      'returnType': 'short',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'var': 'short(*)__array2'}}],
                              'getShort3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'short(*)__array3'}},
                                                      'args': [('var',
                                                                'short(*)__array3',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet a value from the three dimensional array. Ensure that indicies are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c'],
                                                      'inverse': ('setShort3ArrayItem',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                     'qualifiers': [],
                                                                     'type': 'short'},
                                                      'returnType': 'short',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'var': 'short(*)__array3'}}],
                              'getShort4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'short(*)__array4'}},
                                                      'args': [('var',
                                                                'short(*)__array4',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet a value from the four dimensional array. Ensure that indicies are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c'],
                                                      'inverse': ('setShort4ArrayItem',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                     'qualifiers': [],
                                                                     'type': 'short'},
                                                      'returnType': 'short',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'var': 'short(*)__array4'}}],
                              'getShortArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                           'type': 'uint'},
                                                                 'var': {'doc': 'Array to read from. ',
                                                                         'type': 'short'}},
                                                     'args': [('var',
                                                               'short',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nGet a short value from an array. Ensure that index is valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Value of the element. ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': True,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'var': ['*']},
                                                     'types': {'index': 'uint',
                                                               'var': 'short'}}],
                              'getUchar': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                                'type': 'uchar'}},
                                            'args': [('var',
                                                      'uchar',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nGet the value of an unsigned char reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                            'inArgs': [],
                                            'inverse': ('setUchar',
                                                        False),
                                            'outArgs': ['var'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': True,
                                            'typeQualifiers': {'var': ['unsigned',
                                                                       '&']},
                                            'types': {'var': 'uchar'}}],
                              'getUcharArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                           'type': 'uint'},
                                                                 'var': {'doc': 'Array to read from. ',
                                                                         'type': 'uchar'}},
                                                     'args': [('var',
                                                               'uchar',
                                                               'in'),
                                                              ('index',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nGet an unsigned char value from an array. Ensure that index is valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'index'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Value of the element. ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': True,
                                                     'typeQualifiers': {'index': ['unsigned'],
                                                                        'var': ['unsigned',
                                                                                '*']},
                                                     'types': {'index': 'uint',
                                                               'var': 'uchar'}}],
                              'getUint': [{'argInfo': {'var': {'doc': 'Reference to the variable to return. ',
                                                               'type': 'uint'}},
                                           'args': [('var',
                                                     'uint',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nGet the value of an unsigned int reference.  Parameters: \n \n [in]  var  Reference to the variable to return.  \n \n \n',
                                           'inArgs': [],
                                           'inverse': ('setUint', False),
                                           'outArgs': ['var'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': True,
                                           'typeQualifiers': {'var': ['unsigned',
                                                                      '&']},
                                           'types': {'var': 'uint'}}],
                              'getUint2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                       'type': 'uint'},
                                                                 'r': {'doc': 'First index in the array. ',
                                                                       'type': 'uint'},
                                                                 'var': {'doc': 'Array to read from. ',
                                                                         'type': 'int(*)__array2'}},
                                                     'args': [('var',
                                                               'int(*)__array2',
                                                               'in'),
                                                              ('r',
                                                               'uint',
                                                               'in'),
                                                              ('c',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nGet a value from the two dimensional array. Ensure that indicies are valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'r',
                                                                'c'],
                                                     'inverse': ('setUint2ArrayItem',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': True,
                                                     'typeQualifiers': {'c': ['unsigned'],
                                                                        'r': ['unsigned'],
                                                                        'var': ['unsigned']},
                                                     'types': {'c': 'uint',
                                                               'r': 'uint',
                                                               'var': 'int(*)__array2'}}],
                              'getUint3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                       'type': 'uint'},
                                                                 'r': {'doc': 'First index in the array. ',
                                                                       'type': 'uint'},
                                                                 'var': {'doc': 'Array to read from. ',
                                                                         'type': 'int(*)__array3'}},
                                                     'args': [('var',
                                                               'int(*)__array3',
                                                               'in'),
                                                              ('r',
                                                               'uint',
                                                               'in'),
                                                              ('c',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nGet a value from the three dimensional array. Ensure that indicies are valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'r',
                                                                'c'],
                                                     'inverse': ('setUint3ArrayItem',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': True,
                                                     'typeQualifiers': {'c': ['unsigned'],
                                                                        'r': ['unsigned'],
                                                                        'var': ['unsigned']},
                                                     'types': {'c': 'uint',
                                                               'r': 'uint',
                                                               'var': 'int(*)__array3'}}],
                              'getUint4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array.',
                                                                       'type': 'uint'},
                                                                 'r': {'doc': 'First index in the array. ',
                                                                       'type': 'uint'},
                                                                 'var': {'doc': 'Array to read from. ',
                                                                         'type': 'int(*)__array4'}},
                                                     'args': [('var',
                                                               'int(*)__array4',
                                                               'in'),
                                                              ('r',
                                                               'uint',
                                                               'in'),
                                                              ('c',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nGet a value from the four dimensional array. Ensure that indicies are valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'r',
                                                                'c'],
                                                     'inverse': ('setUint4ArrayItem',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Value of the element: var[r][c] ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': True,
                                                     'typeQualifiers': {'c': ['unsigned'],
                                                                        'r': ['unsigned'],
                                                                        'var': ['unsigned']},
                                                     'types': {'c': 'uint',
                                                               'r': 'uint',
                                                               'var': 'int(*)__array4'}}],
                              'getUintArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                          'type': 'uint'},
                                                                'var': {'doc': 'Array to read from. ',
                                                                        'type': 'uint'}},
                                                    'args': [('var',
                                                              'uint',
                                                              'in'),
                                                             ('index',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nGet an unsigned value from an array. Ensure that index is valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'index'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Value of the element. ',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': True,
                                                    'typeQualifiers': {'index': ['unsigned'],
                                                                       'var': ['unsigned',
                                                                               '*']},
                                                    'types': {'index': 'uint',
                                                              'var': 'uint'}}],
                              'getUshortArrayItem': [{'argInfo': {'index': {'doc': 'Index of the element to be returned.',
                                                                            'type': 'uint'},
                                                                  'var': {'doc': 'Array to read from. ',
                                                                          'type': 'short'}},
                                                      'args': [('var',
                                                                'short',
                                                                'in'),
                                                               ('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nGet an unsigned short value from an array. Ensure that index is valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Value of the element. ',
                                                                     'qualifiers': [],
                                                                     'type': 'int'},
                                                      'returnType': 'int',
                                                      'static': True,
                                                      'typeQualifiers': {'index': ['unsigned'],
                                                                         'var': ['unsigned',
                                                                                 '*']},
                                                      'types': {'index': 'uint',
                                                                'var': 'short'}}],
                              'setBool': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                 'type': 'int'},
                                                       'var': {'doc': 'Reference to the variable to be assigned. ',
                                                               'type': 'bool'}},
                                           'args': [('var',
                                                     'bool',
                                                     'out'),
                                                    ('value',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSet a bool reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                           'inArgs': ['value'],
                                           'inverse': ('getBool', True),
                                           'outArgs': ['var'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'value': [],
                                                              'var': ['&']},
                                           'types': {'value': 'int',
                                                     'var': 'bool'}}],
                              'setBoolArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                      'type': 'uint'},
                                                            'value': {'doc': 'New value to be assigned.',
                                                                      'type': 'int'},
                                                            'var': {'doc': 'Array to assign to. ',
                                                                    'type': 'bool'}},
                                                'args': [('var',
                                                          'bool',
                                                          'out'),
                                                         ('index',
                                                          'uint',
                                                          'in'),
                                                         ('value',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSet a bool value in an array. Ensure that index is valid before calling this method.',
                                                'inArgs': ['index',
                                                           'value'],
                                                'outArgs': ['var'],
                                                'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'index': ['unsigned'],
                                                                   'value': [],
                                                                   'var': ['*']},
                                                'types': {'index': 'uint',
                                                          'value': 'int',
                                                          'var': 'bool'}}],
                              'setChar': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                 'type': 'int'},
                                                       'var': {'doc': 'Reference to the variable to be assigned. ',
                                                               'type': 'char'}},
                                           'args': [('var',
                                                     'char',
                                                     'out'),
                                                    ('value',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSet a char reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                           'inArgs': ['value'],
                                           'inverse': ('getChar', True),
                                           'outArgs': ['var'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'value': [],
                                                              'var': ['&']},
                                           'types': {'value': 'int',
                                                     'var': 'char'}}],
                              'setCharArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                      'type': 'uint'},
                                                            'value': {'doc': 'New value to be assigned.',
                                                                      'type': 'int'},
                                                            'var': {'doc': 'Array to assign to. ',
                                                                    'type': 'char'}},
                                                'args': [('var',
                                                          'char',
                                                          'out'),
                                                         ('index',
                                                          'uint',
                                                          'in'),
                                                         ('value',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSet a char value in an array. Ensure that index is valid before calling this method.',
                                                'inArgs': ['index',
                                                           'value'],
                                                'outArgs': ['var'],
                                                'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'index': ['unsigned'],
                                                                   'value': [],
                                                                   'var': ['*']},
                                                'types': {'index': 'uint',
                                                          'value': 'int',
                                                          'var': 'char'}}],
                              'setDouble': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                   'type': 'double'},
                                                         'var': {'doc': 'Reference to the variable to be assigned. ',
                                                                 'type': 'double'}},
                                             'args': [('var',
                                                       'double',
                                                       'out'),
                                                      ('value',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSet a double reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                             'inArgs': ['value'],
                                             'inverse': ('getDouble',
                                                         True),
                                             'outArgs': ['var'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'value': [],
                                                                'var': ['&']},
                                             'types': {'value': 'double',
                                                       'var': 'double'}}],
                              'setDouble2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                         'type': 'uint'},
                                                                   'r': {'doc': 'First index in the array. ',
                                                                         'type': 'uint'},
                                                                   'value': {'doc': 'Value to set into the element.',
                                                                             'type': 'double'},
                                                                   'var': {'doc': 'Array to assign to. ',
                                                                           'type': 'double(*)__array2'}},
                                                       'args': [('var',
                                                                 'double(*)__array2',
                                                                 'in'),
                                                                ('r',
                                                                 'uint',
                                                                 'in'),
                                                                ('c',
                                                                 'uint',
                                                                 'in'),
                                                                ('value',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSet a value in the two dimensional array. Ensure that indices are valid before calling this method.',
                                                       'inArgs': ['var',
                                                                  'r',
                                                                  'c',
                                                                  'value'],
                                                       'inverse': ('getDouble2ArrayItem',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': True,
                                                       'typeQualifiers': {'c': ['unsigned'],
                                                                          'r': ['unsigned'],
                                                                          'value': [],
                                                                          'var': []},
                                                       'types': {'c': 'uint',
                                                                 'r': 'uint',
                                                                 'value': 'double',
                                                                 'var': 'double(*)__array2'}}],
                              'setDouble3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                         'type': 'uint'},
                                                                   'r': {'doc': 'First index in the array. ',
                                                                         'type': 'uint'},
                                                                   'value': {'doc': 'Value to set into the element.',
                                                                             'type': 'double'},
                                                                   'var': {'doc': 'Array to assign to. ',
                                                                           'type': 'double(*)__array3'}},
                                                       'args': [('var',
                                                                 'double(*)__array3',
                                                                 'in'),
                                                                ('r',
                                                                 'uint',
                                                                 'in'),
                                                                ('c',
                                                                 'uint',
                                                                 'in'),
                                                                ('value',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSet a value in the three dimensional array. Ensure that indices are valid before calling this method.',
                                                       'inArgs': ['var',
                                                                  'r',
                                                                  'c',
                                                                  'value'],
                                                       'inverse': ('getDouble3ArrayItem',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': True,
                                                       'typeQualifiers': {'c': ['unsigned'],
                                                                          'r': ['unsigned'],
                                                                          'value': [],
                                                                          'var': []},
                                                       'types': {'c': 'uint',
                                                                 'r': 'uint',
                                                                 'value': 'double',
                                                                 'var': 'double(*)__array3'}}],
                              'setDouble4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                         'type': 'uint'},
                                                                   'r': {'doc': 'First index in the array. ',
                                                                         'type': 'uint'},
                                                                   'value': {'doc': 'Value to set into the element.',
                                                                             'type': 'double'},
                                                                   'var': {'doc': 'Array to assign to. ',
                                                                           'type': 'double(*)__array4'}},
                                                       'args': [('var',
                                                                 'double(*)__array4',
                                                                 'in'),
                                                                ('r',
                                                                 'uint',
                                                                 'in'),
                                                                ('c',
                                                                 'uint',
                                                                 'in'),
                                                                ('value',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nSet a value in the four dimensional array. Ensure that indices are valid before calling this method.',
                                                       'inArgs': ['var',
                                                                  'r',
                                                                  'c',
                                                                  'value'],
                                                       'inverse': ('getDouble4ArrayItem',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': True,
                                                       'typeQualifiers': {'c': ['unsigned'],
                                                                          'r': ['unsigned'],
                                                                          'value': [],
                                                                          'var': []},
                                                       'types': {'c': 'uint',
                                                                 'r': 'uint',
                                                                 'value': 'double',
                                                                 'var': 'double(*)__array4'}}],
                              'setDoubleArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                        'type': 'uint'},
                                                              'value': {'doc': 'New value to be assigned.',
                                                                        'type': 'double'},
                                                              'var': {'doc': 'Array to assign to. ',
                                                                      'type': 'double'}},
                                                  'args': [('var',
                                                            'double',
                                                            'out'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('value',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nSet a double value in an array. Ensure that index is valid before calling this method.',
                                                  'inArgs': ['index',
                                                             'value'],
                                                  'outArgs': ['var'],
                                                  'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': True,
                                                  'typeQualifiers': {'index': ['unsigned'],
                                                                     'value': [],
                                                                     'var': ['*']},
                                                  'types': {'index': 'uint',
                                                            'value': 'double',
                                                            'var': 'double'}}],
                              'setFloat': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                  'type': 'double'},
                                                        'var': {'doc': 'Reference to the variable to be assigned. ',
                                                                'type': 'float'}},
                                            'args': [('var',
                                                      'float',
                                                      'out'),
                                                     ('value',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSet a float reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                            'inArgs': ['value'],
                                            'inverse': ('getFloat', True),
                                            'outArgs': ['var'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'value': [],
                                                               'var': ['&']},
                                            'types': {'value': 'double',
                                                      'var': 'float'}}],
                              'setFloat2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'value': {'doc': 'Value to set into the element.',
                                                                            'type': 'float'},
                                                                  'var': {'doc': 'Array to assign to. ',
                                                                          'type': 'float(*)__array2'}},
                                                      'args': [('var',
                                                                'float(*)__array2',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in'),
                                                               ('value',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet a value in the two dimensional array. Ensure that indices are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c',
                                                                 'value'],
                                                      'inverse': ('getFloat2ArrayItem',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'value': [],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'value': 'float',
                                                                'var': 'float(*)__array2'}}],
                              'setFloat3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'value': {'doc': 'Value to set into the element.',
                                                                            'type': 'float'},
                                                                  'var': {'doc': 'Array to assign to. ',
                                                                          'type': 'float(*)__array3'}},
                                                      'args': [('var',
                                                                'float(*)__array3',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in'),
                                                               ('value',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet a value in the three dimensional array. Ensure that indices are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c',
                                                                 'value'],
                                                      'inverse': ('getFloat3ArrayItem',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'value': [],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'value': 'float',
                                                                'var': 'float(*)__array3'}}],
                              'setFloat4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'value': {'doc': 'Value to set into the element.',
                                                                            'type': 'float'},
                                                                  'var': {'doc': 'Array to assign to. ',
                                                                          'type': 'float(*)__array4'}},
                                                      'args': [('var',
                                                                'float(*)__array4',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in'),
                                                               ('value',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet a value in the four dimensional array. Ensure that indices are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c',
                                                                 'value'],
                                                      'inverse': ('getFloat4ArrayItem',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'value': [],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'value': 'float',
                                                                'var': 'float(*)__array4'}}],
                              'setFloatArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                       'type': 'uint'},
                                                             'value': {'doc': 'New value to be assigned.',
                                                                       'type': 'double'},
                                                             'var': {'doc': 'Array to assign to. ',
                                                                     'type': 'float'}},
                                                 'args': [('var',
                                                           'float',
                                                           'out'),
                                                          ('index',
                                                           'uint',
                                                           'in'),
                                                          ('value',
                                                           'double',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSet a float value in an array. Ensure that index is valid before calling this method.',
                                                 'inArgs': ['index',
                                                            'value'],
                                                 'outArgs': ['var'],
                                                 'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {'index': ['unsigned'],
                                                                    'value': [],
                                                                    'var': ['*']},
                                                 'types': {'index': 'uint',
                                                           'value': 'double',
                                                           'var': 'float'}}],
                              'setInt': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                'type': 'int'},
                                                      'var': {'doc': 'Reference to the variable to be assigned. ',
                                                              'type': 'int'}},
                                          'args': [('var', 'int', 'out'),
                                                   ('value',
                                                    'int',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nSet an integer reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                          'inArgs': ['value'],
                                          'inverse': ('getInt', True),
                                          'outArgs': ['var'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': True,
                                          'typeQualifiers': {'value': [],
                                                             'var': ['&']},
                                          'types': {'value': 'int',
                                                    'var': 'int'}}],
                              'setInt2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                      'type': 'uint'},
                                                                'r': {'doc': 'First index in the array. ',
                                                                      'type': 'uint'},
                                                                'value': {'doc': 'Value to set into the element.',
                                                                          'type': 'int'},
                                                                'var': {'doc': 'Array to assign to. ',
                                                                        'type': 'int(*)__array2'}},
                                                    'args': [('var',
                                                              'int(*)__array2',
                                                              'in'),
                                                             ('r',
                                                              'uint',
                                                              'in'),
                                                             ('c',
                                                              'uint',
                                                              'in'),
                                                             ('value',
                                                              'int',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSet a value in the two dimensional array. Ensure that indices are valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'r',
                                                               'c',
                                                               'value'],
                                                    'inverse': ('getInt2ArrayItem',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': True,
                                                    'typeQualifiers': {'c': ['unsigned'],
                                                                       'r': ['unsigned'],
                                                                       'value': [],
                                                                       'var': []},
                                                    'types': {'c': 'uint',
                                                              'r': 'uint',
                                                              'value': 'int',
                                                              'var': 'int(*)__array2'}}],
                              'setInt3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                      'type': 'uint'},
                                                                'r': {'doc': 'First index in the array. ',
                                                                      'type': 'uint'},
                                                                'value': {'doc': 'Value to set into the element.',
                                                                          'type': 'int'},
                                                                'var': {'doc': 'Array to assign to. ',
                                                                        'type': 'int(*)__array3'}},
                                                    'args': [('var',
                                                              'int(*)__array3',
                                                              'in'),
                                                             ('r',
                                                              'uint',
                                                              'in'),
                                                             ('c',
                                                              'uint',
                                                              'in'),
                                                             ('value',
                                                              'int',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSet a value in the three dimensional array. Ensure that indices are valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'r',
                                                               'c',
                                                               'value'],
                                                    'inverse': ('getInt3ArrayItem',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': True,
                                                    'typeQualifiers': {'c': ['unsigned'],
                                                                       'r': ['unsigned'],
                                                                       'value': [],
                                                                       'var': []},
                                                    'types': {'c': 'uint',
                                                              'r': 'uint',
                                                              'value': 'int',
                                                              'var': 'int(*)__array3'}}],
                              'setInt4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                      'type': 'uint'},
                                                                'r': {'doc': 'First index in the array. ',
                                                                      'type': 'uint'},
                                                                'value': {'doc': 'Value to set into the element.',
                                                                          'type': 'int'},
                                                                'var': {'doc': 'Array to assign to. ',
                                                                        'type': 'int(*)__array4'}},
                                                    'args': [('var',
                                                              'int(*)__array4',
                                                              'in'),
                                                             ('r',
                                                              'uint',
                                                              'in'),
                                                             ('c',
                                                              'uint',
                                                              'in'),
                                                             ('value',
                                                              'int',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSet a value in the four dimensional array. Ensure that indices are valid before calling this method.',
                                                    'inArgs': ['var',
                                                               'r',
                                                               'c',
                                                               'value'],
                                                    'inverse': ('getInt4ArrayItem',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': True,
                                                    'typeQualifiers': {'c': ['unsigned'],
                                                                       'r': ['unsigned'],
                                                                       'value': [],
                                                                       'var': []},
                                                    'types': {'c': 'uint',
                                                              'r': 'uint',
                                                              'value': 'int',
                                                              'var': 'int(*)__array4'}}],
                              'setIntArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                     'type': 'uint'},
                                                           'value': {'doc': 'New value to be assigned.',
                                                                     'type': 'int'},
                                                           'var': {'doc': 'Array to assign to. ',
                                                                   'type': 'int'}},
                                               'args': [('var',
                                                         'int',
                                                         'out'),
                                                        ('index',
                                                         'uint',
                                                         'in'),
                                                        ('value',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nSet an integer value in an array. Ensure that index is valid before calling this method.',
                                               'inArgs': ['index',
                                                          'value'],
                                               'outArgs': ['var'],
                                               'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': True,
                                               'typeQualifiers': {'index': ['unsigned'],
                                                                  'value': [],
                                                                  'var': ['*']},
                                               'types': {'index': 'uint',
                                                         'value': 'int',
                                                         'var': 'int'}}],
                              'setShort': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                  'type': 'int'},
                                                        'var': {'doc': 'Reference to the variable to be assigned. ',
                                                                'type': 'short'}},
                                            'args': [('var',
                                                      'short',
                                                      'out'),
                                                     ('value',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSet a short reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                            'inArgs': ['value'],
                                            'inverse': ('getShort', True),
                                            'outArgs': ['var'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'value': [],
                                                               'var': ['&']},
                                            'types': {'value': 'int',
                                                      'var': 'short'}}],
                              'setShort2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'value': {'doc': 'Value to set into the element.',
                                                                            'type': 'short'},
                                                                  'var': {'doc': 'Array to assign to. ',
                                                                          'type': 'short(*)__array2'}},
                                                      'args': [('var',
                                                                'short(*)__array2',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in'),
                                                               ('value',
                                                                'short',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet a value in the two dimensional array. Ensure that indices are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c',
                                                                 'value'],
                                                      'inverse': ('getShort2ArrayItem',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'value': [],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'value': 'short',
                                                                'var': 'short(*)__array2'}}],
                              'setShort3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'value': {'doc': 'Value to set into the element.',
                                                                            'type': 'short'},
                                                                  'var': {'doc': 'Array to assign to. ',
                                                                          'type': 'short(*)__array3'}},
                                                      'args': [('var',
                                                                'short(*)__array3',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in'),
                                                               ('value',
                                                                'short',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet a value in the three dimensional array. Ensure that indices are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c',
                                                                 'value'],
                                                      'inverse': ('getShort3ArrayItem',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'value': [],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'value': 'short',
                                                                'var': 'short(*)__array3'}}],
                              'setShort4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                        'type': 'uint'},
                                                                  'r': {'doc': 'First index in the array. ',
                                                                        'type': 'uint'},
                                                                  'value': {'doc': 'Value to set into the element.',
                                                                            'type': 'short'},
                                                                  'var': {'doc': 'Array to assign to. ',
                                                                          'type': 'short(*)__array4'}},
                                                      'args': [('var',
                                                                'short(*)__array4',
                                                                'in'),
                                                               ('r',
                                                                'uint',
                                                                'in'),
                                                               ('c',
                                                                'uint',
                                                                'in'),
                                                               ('value',
                                                                'short',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSet a value in the two dimensional array. Ensure that indices are valid before calling this method.',
                                                      'inArgs': ['var',
                                                                 'r',
                                                                 'c',
                                                                 'value'],
                                                      'inverse': ('getShort4ArrayItem',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': True,
                                                      'typeQualifiers': {'c': ['unsigned'],
                                                                         'r': ['unsigned'],
                                                                         'value': [],
                                                                         'var': []},
                                                      'types': {'c': 'uint',
                                                                'r': 'uint',
                                                                'value': 'short',
                                                                'var': 'short(*)__array4'}}],
                              'setShortArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                       'type': 'uint'},
                                                             'value': {'doc': 'New value to be assigned.',
                                                                       'type': 'int'},
                                                             'var': {'doc': 'Array to assign to. ',
                                                                     'type': 'short'}},
                                                 'args': [('var',
                                                           'short',
                                                           'out'),
                                                          ('index',
                                                           'uint',
                                                           'in'),
                                                          ('value',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSet a short value in an array. Ensure that index is valid before calling this method.',
                                                 'inArgs': ['index',
                                                            'value'],
                                                 'outArgs': ['var'],
                                                 'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {'index': ['unsigned'],
                                                                    'value': [],
                                                                    'var': ['*']},
                                                 'types': {'index': 'uint',
                                                           'value': 'int',
                                                           'var': 'short'}}],
                              'setUchar': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                  'type': 'int'},
                                                        'var': {'doc': 'Reference to the variable to be assigned. ',
                                                                'type': 'uchar'}},
                                            'args': [('var',
                                                      'uchar',
                                                      'out'),
                                                     ('value',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSet an unsigned char reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                            'inArgs': ['value'],
                                            'inverse': ('getUchar', True),
                                            'outArgs': ['var'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'value': [],
                                                               'var': ['unsigned',
                                                                       '&']},
                                            'types': {'value': 'int',
                                                      'var': 'uchar'}}],
                              'setUcharArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                       'type': 'uint'},
                                                             'value': {'doc': 'New value to be assigned.',
                                                                       'type': 'int'},
                                                             'var': {'doc': 'Array to assign to. ',
                                                                     'type': 'uchar'}},
                                                 'args': [('var',
                                                           'uchar',
                                                           'out'),
                                                          ('index',
                                                           'uint',
                                                           'in'),
                                                          ('value',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSet an unsigned char value in an array. Ensure that index is valid before calling this method.',
                                                 'inArgs': ['index',
                                                            'value'],
                                                 'outArgs': ['var'],
                                                 'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': True,
                                                 'typeQualifiers': {'index': ['unsigned'],
                                                                    'value': [],
                                                                    'var': ['unsigned',
                                                                            '*']},
                                                 'types': {'index': 'uint',
                                                           'value': 'int',
                                                           'var': 'uchar'}}],
                              'setUint': [{'argInfo': {'value': {'doc': 'Value to assign ',
                                                                 'type': 'int'},
                                                       'var': {'doc': 'Reference to the variable to be assigned. ',
                                                               'type': 'uint'}},
                                           'args': [('var',
                                                     'uint',
                                                     'out'),
                                                    ('value',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSet an unsigned integer reference value.  Parameters: \n \n [out]  var  Reference to the variable to be assigned.  \n [in]  value  Value to assign  \n \n \n',
                                           'inArgs': ['value'],
                                           'inverse': ('getUint', True),
                                           'outArgs': ['var'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': True,
                                           'typeQualifiers': {'value': [],
                                                              'var': ['unsigned',
                                                                      '&']},
                                           'types': {'value': 'int',
                                                     'var': 'uint'}}],
                              'setUint2ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                       'type': 'uint'},
                                                                 'r': {'doc': 'First index in the array. ',
                                                                       'type': 'uint'},
                                                                 'value': {'doc': 'Value to set into the element.',
                                                                           'type': 'uint'},
                                                                 'var': {'doc': 'Array to assign to. ',
                                                                         'type': 'int(*)__array2'}},
                                                     'args': [('var',
                                                               'int(*)__array2',
                                                               'in'),
                                                              ('r',
                                                               'uint',
                                                               'in'),
                                                              ('c',
                                                               'uint',
                                                               'in'),
                                                              ('value',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSet a value in the two dimensional array. Ensure that indices are valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'r',
                                                                'c',
                                                                'value'],
                                                     'inverse': ('getUint2ArrayItem',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {'c': ['unsigned'],
                                                                        'r': ['unsigned'],
                                                                        'value': ['unsigned'],
                                                                        'var': ['unsigned']},
                                                     'types': {'c': 'uint',
                                                               'r': 'uint',
                                                               'value': 'uint',
                                                               'var': 'int(*)__array2'}}],
                              'setUint3ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                       'type': 'uint'},
                                                                 'r': {'doc': 'First index in the array. ',
                                                                       'type': 'uint'},
                                                                 'value': {'doc': 'Value to set into the element.',
                                                                           'type': 'uint'},
                                                                 'var': {'doc': 'Array to assign to. ',
                                                                         'type': 'int(*)__array3'}},
                                                     'args': [('var',
                                                               'int(*)__array3',
                                                               'in'),
                                                              ('r',
                                                               'uint',
                                                               'in'),
                                                              ('c',
                                                               'uint',
                                                               'in'),
                                                              ('value',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSet a value in the three dimensional array. Ensure that indices are valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'r',
                                                                'c',
                                                                'value'],
                                                     'inverse': ('getUint3ArrayItem',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {'c': ['unsigned'],
                                                                        'r': ['unsigned'],
                                                                        'value': ['unsigned'],
                                                                        'var': ['unsigned']},
                                                     'types': {'c': 'uint',
                                                               'r': 'uint',
                                                               'value': 'uint',
                                                               'var': 'int(*)__array3'}}],
                              'setUint4ArrayItem': [{'argInfo': {'c': {'doc': 'Second index in the array. ',
                                                                       'type': 'uint'},
                                                                 'r': {'doc': 'First index in the array. ',
                                                                       'type': 'uint'},
                                                                 'value': {'doc': 'Value to set into the element.',
                                                                           'type': 'uint'},
                                                                 'var': {'doc': 'Array to assign to. ',
                                                                         'type': 'int(*)__array4'}},
                                                     'args': [('var',
                                                               'int(*)__array4',
                                                               'in'),
                                                              ('r',
                                                               'uint',
                                                               'in'),
                                                              ('c',
                                                               'uint',
                                                               'in'),
                                                              ('value',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSet a value in the four dimensional array. Ensure that indices are valid before calling this method.',
                                                     'inArgs': ['var',
                                                                'r',
                                                                'c',
                                                                'value'],
                                                     'inverse': ('getUint4ArrayItem',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {'c': ['unsigned'],
                                                                        'r': ['unsigned'],
                                                                        'value': ['unsigned'],
                                                                        'var': ['unsigned']},
                                                     'types': {'c': 'uint',
                                                               'r': 'uint',
                                                               'value': 'uint',
                                                               'var': 'int(*)__array4'}}],
                              'setUintArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                      'type': 'uint'},
                                                            'value': {'doc': 'New value to be assigned.',
                                                                      'type': 'int'},
                                                            'var': {'doc': 'Array to assign to. ',
                                                                    'type': 'uint'}},
                                                'args': [('var',
                                                          'uint',
                                                          'out'),
                                                         ('index',
                                                          'uint',
                                                          'in'),
                                                         ('value',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSet an unsigned integer value in an array. Ensure that index is valid before calling this method.',
                                                'inArgs': ['index',
                                                           'value'],
                                                'outArgs': ['var'],
                                                'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': True,
                                                'typeQualifiers': {'index': ['unsigned'],
                                                                   'value': [],
                                                                   'var': ['unsigned',
                                                                           '*']},
                                                'types': {'index': 'uint',
                                                          'value': 'int',
                                                          'var': 'uint'}}],
                              'setUshortArray': [{'argInfo': {'index': {'doc': 'Index of the element to be modified. ',
                                                                        'type': 'uint'},
                                                              'value': {'doc': 'New value to be assigned.',
                                                                        'type': 'int'},
                                                              'var': {'doc': 'Array to assign to. ',
                                                                      'type': 'short'}},
                                                  'args': [('var',
                                                            'short',
                                                            'out'),
                                                           ('index',
                                                            'uint',
                                                            'in'),
                                                           ('value',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nSet an unsigned short value in an array. Ensure that index is valid before calling this method.',
                                                  'inArgs': ['index',
                                                             'value'],
                                                  'outArgs': ['var'],
                                                  'returnInfo': {'doc': 'True on success, false otherwise. ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': True,
                                                  'typeQualifiers': {'index': ['unsigned'],
                                                                     'value': [],
                                                                     'var': ['unsigned',
                                                                             '*']},
                                                  'types': {'index': 'uint',
                                                            'value': 'int',
                                                            'var': 'short'}}]},
                  'pymelEnums': {}},
  'MSelectInfo': {'enums': {},
                  'invertibles': [('setHighestPriority', 'highestPriority')],
                  'methods': {'addSelection': [{'argInfo': {'isComponent': {'doc': 'Indicates whether item to be added is an object or a component ',
                                                                            'type': 'bool'},
                                                            'item': {'doc': 'The component or object to add to the list ',
                                                                     'type': 'MSelectionList'},
                                                            'list': {'doc': 'The selection list to add the item(s) to ',
                                                                     'type': 'MSelectionList'},
                                                            'mask': {'doc': 'Mask used to determine selection priority ',
                                                                     'type': 'MSelectionMask'},
                                                            'point': {'doc': 'The world space point representing the selected object. This is used during single-click selection when the click overlaps multiple objects in order to determine which point is closest to the camera. ',
                                                                      'type': 'MPoint'},
                                                            'points': {'doc': 'A copy of the points of all currently selected components in the list (if components are selected) ',
                                                                       'type': 'MPointArray'}},
                                                'args': [('item',
                                                          'MSelectionList',
                                                          'in'),
                                                         ('point',
                                                          'MPoint',
                                                          'in'),
                                                         ('list',
                                                          'MSelectionList',
                                                          'out'),
                                                         ('points',
                                                          'MPointArray',
                                                          'out'),
                                                         ('mask',
                                                          'MSelectionMask',
                                                          'in'),
                                                         ('isComponent',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nAdds components or objects to the active selection list. For an example of how this is used please refer to the method definition apiMeshShapeUI::select() in the devkit example code apiMeshShape.cpp.',
                                                'inArgs': ['item',
                                                           'point',
                                                           'mask',
                                                           'isComponent'],
                                                'outArgs': ['list',
                                                            'points'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'isComponent': [],
                                                                   'item': ['const',
                                                                            '&'],
                                                                   'list': ['&'],
                                                                   'mask': ['const',
                                                                            '&'],
                                                                   'point': ['const',
                                                                             '&'],
                                                                   'points': ['&']},
                                                'types': {'isComponent': 'bool',
                                                          'item': 'MSelectionList',
                                                          'list': 'MSelectionList',
                                                          'mask': 'MSelectionMask',
                                                          'point': 'MPoint',
                                                          'points': 'MPointArray'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nReturns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'getAlignmentMatrix': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the alignment matrix. This method is used to find ray object intersection.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'MMatrix'},
                                                      'returnType': 'MMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                              'getLocalRay': [{'argInfo': {'pnt': {'doc': 'ray starting point ',
                                                                   'type': 'MPoint'},
                                                           'vec': {'doc': 'ray direction ',
                                                                   'type': 'MVector'}},
                                               'args': [('pnt',
                                                         'MPoint',
                                                         'out'),
                                                        ('vec',
                                                         'MVector',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nGet the selection ray. This method isused to find ray object intersection.',
                                               'inArgs': [],
                                               'outArgs': ['pnt', 'vec'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'pnt': ['&'],
                                                                  'vec': ['&']},
                                               'types': {'pnt': 'MPoint',
                                                         'vec': 'MVector'}}],
                              'highestPriority': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the highest selection priority value.',
                                                   'inArgs': [],
                                                   'inverse': ('setHighestPriority',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                              'isRay': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nIs there a selection ray. This method isused to find ray object intersection.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'selectClosest': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nDetermines if we want to select the closest object.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'selectForHilite': [{'argInfo': {'mask': {'doc': 'the mask to test',
                                                                        'type': 'MSelectionMask'}},
                                                   'args': [('mask',
                                                             'MSelectionMask',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGive the selection mask, can this object be selected for the hilite list.',
                                                   'inArgs': ['mask'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': " true can select for hilite  false can't select for hilite   ",
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'mask': ['const',
                                                                               '&']},
                                                   'types': {'mask': 'MSelectionMask'}}],
                              'selectOnHilitedOnly': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis means that you can only select components if the object is hilited.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                              'selectPath': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns a path to the item that is being selected.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MDagPath'},
                                              'returnType': 'MDagPath',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                              'selectRect': [{'argInfo': {'height': {'doc': 'Height of the selection rectangle. ',
                                                                     'type': 'uint'},
                                                          'width': {'doc': 'Width of the selection rectangle. ',
                                                                    'type': 'uint'},
                                                          'x': {'doc': 'Lower left corner of the selection rectangle (x coordinate). ',
                                                                'type': 'uint'},
                                                          'y': {'doc': 'Lower left corner of the selection rectangle (y coordinate). ',
                                                                'type': 'uint'}},
                                              'args': [('x',
                                                        'uint',
                                                        'out'),
                                                       ('y',
                                                        'uint',
                                                        'out'),
                                                       ('width',
                                                        'uint',
                                                        'out'),
                                                       ('height',
                                                        'uint',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the current selection rectangle dimensions.',
                                              'inArgs': [],
                                              'outArgs': ['x',
                                                          'y',
                                                          'width',
                                                          'height'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'height': ['unsigned',
                                                                            '&'],
                                                                 'width': ['unsigned',
                                                                           '&'],
                                                                 'x': ['unsigned',
                                                                       '&'],
                                                                 'y': ['unsigned',
                                                                       '&']},
                                              'types': {'height': 'uint',
                                                        'width': 'uint',
                                                        'x': 'uint',
                                                        'y': 'uint'}}],
                              'selectable': [{'argInfo': {'mask': {'doc': 'selection mask',
                                                                   'type': 'MSelectionMask'}},
                                              'args': [('mask',
                                                        'MSelectionMask',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGiven the selection mask, this method determines if the object is selectable.',
                                              'inArgs': ['mask'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': ' true the object is selectable  false the object not is selectable   ',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'mask': ['&']},
                                              'types': {'mask': 'MSelectionMask'}}],
                              'selectableComponent': [{'argInfo': {'displayed': {'doc': 'is the component displayed ',
                                                                                 'type': 'bool'},
                                                                   'mask': {'doc': 'selection mask',
                                                                            'type': 'MSelectionMask'}},
                                                       'args': [('displayed',
                                                                 'bool',
                                                                 'in'),
                                                                ('mask',
                                                                 'MSelectionMask',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGiven the selection mask, this method determines if the component is selectable.',
                                                       'inArgs': ['displayed',
                                                                  'mask'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': ' true the component is selectable  false the component not is selectable   ',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'displayed': [],
                                                                          'mask': ['&']},
                                                       'types': {'displayed': 'bool',
                                                                 'mask': 'MSelectionMask'}}],
                              'setHighestPriority': [{'argInfo': {'value': {'doc': 'the priority value ',
                                                                            'type': 'int'}},
                                                      'args': [('value',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the highest selection priority value.',
                                                      'inArgs': ['value'],
                                                      'inverse': ('highestPriority',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'value': []},
                                                      'types': {'value': 'int'}}],
                              'setSnapPoint': [{'argInfo': {'point': {'doc': 'The point to be snapped to ',
                                                                      'type': 'MPoint'}},
                                                'args': [('point',
                                                          'MPoint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "\r\nWhen a snapping operation is being performed the shape's overridden  MPxSurfaceShapeUI::snap()  method can call this method to set the point to be snapped to. If  setSnapPoint()  is called multiple times then the point passed in which is nearest to the current cursor location will be used. So the shape can either compute the snap point itself and call  setSnapPoint()  once or it can make a series of calls and let  setSnapPoint()  determine the closest of those for itself.",
                                                'inArgs': ['point'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': " true the point is closer  false the point isn't closest   ",
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {'point': ['const',
                                                                             '&']},
                                                'types': {'point': 'MPoint'}}],
                              'singleSelection': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis method determines if we want to select a single object.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                              'view': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the view that the current selection is taking place in.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'M3dView'},
                                        'returnType': 'M3dView',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}]},
                  'pymelEnums': {},
                  'pymelMethods': {'highestPriority': 'getHighestPriority'}},
  'MSelectionList': {'enums': {'MergeStrategy': {'valueDocs': {'XORWithList': 'Exclusive OR: if the object is already on the list, remove it, otherwise add it.',
                                                               'kMergeNormal': 'If the object is not already on the list, add it.',
                                                               'kRemoveFromList': 'Remove the object from the list.',
                                                               'kXORWithList': 'Exclusive OR: if the object is already on the list, remove it, otherwise add it.',
                                                               'mergeNormal': 'If the object is not already on the list, add it.',
                                                               'removeFromList': 'Remove the object from the list.'},
                                                 'values': "Enum('MergeStrategy', {'kMergeNormal': 0, 'kXORWithList': 1, 'kRemoveFromList': 2})"}},
                     'methods': {'add': [{'argInfo': {'mergeWithExisting': {'doc': 'This parameter determines what to do if the given item is already present in the list: \r  If true, the given item is unconditionally added to the end of the list without affecting the pre-existing item. \r  If false, the pre-existing item is moved from its current position to the end of the list.',
                                                                            'type': 'bool'},
                                                      'object': {'doc': 'The object to add ',
                                                                 'type': 'MObject'}},
                                          'args': [('object',
                                                    'MObject',
                                                    'in'),
                                                   ('mergeWithExisting',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'mergeWithExisting': False},
                                          'deprecated': False,
                                          'doc': '\r\nAdd the specified DG node to the end of the selection list.',
                                          'inArgs': ['object',
                                                     'mergeWithExisting'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'mergeWithExisting': ['const'],
                                                             'object': ['const',
                                                                        '&']},
                                          'types': {'mergeWithExisting': 'bool',
                                                    'object': 'MObject'}},
                                         {'argInfo': {'component': {'doc': 'components of the object ',
                                                                    'type': 'MObject'},
                                                      'mergeWithExisting': {'doc': 'This parameter determines what to do if the given item is already present in the list: \r  If true, the given item is unconditionally added to the end of the list without affecting the pre-existing item. \r  If false, the pre-existing item is moved from its current position to the end of the list. In addition, if the pre-existing item already had components specified, the components from the given item are merged into those of the pre-existing item.',
                                                                            'type': 'bool'},
                                                      'object': {'doc': 'The Dag Object to add ',
                                                                 'type': 'MDagPath'}},
                                          'args': [('object',
                                                    'MDagPath',
                                                    'in'),
                                                   ('component',
                                                    'MObject',
                                                    'in'),
                                                   ('mergeWithExisting',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'component': 'MObject::kNullObj',
                                                       'mergeWithExisting': False},
                                          'deprecated': False,
                                          'doc': '\r\nAdd the specified DG node to the end of the selection list.',
                                          'inArgs': ['object',
                                                     'component',
                                                     'mergeWithExisting'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'component': ['const',
                                                                           '&'],
                                                             'mergeWithExisting': ['const'],
                                                             'object': ['const',
                                                                        '&']},
                                          'types': {'component': 'MObject',
                                                    'mergeWithExisting': 'bool',
                                                    'object': 'MDagPath'}},
                                         {'argInfo': {'matchString': {'doc': 'object match string ',
                                                                      'type': 'MString'},
                                                      'searchChildNamespacesToo': {'doc': 'optional parameter to specify that child namespaces will also be searched. A value of true enables child namespace searching; a value of false (the default) only searches within the namespace. See the above description for details on which namespace gets searched.',
                                                                                   'type': 'bool'}},
                                          'args': [('matchString',
                                                    'MString',
                                                    'in'),
                                                   ('searchChildNamespacesToo',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'searchChildNamespacesToo': False},
                                          'deprecated': False,
                                          'doc': '\r\nAdd the specified object(s) to the selection list. There is an option to search all child namespaces. The object name should be specified in the same way it would be in the MEL language. It is possible to use wildcard characters, so multiple objects may be added in one method call.',
                                          'inArgs': ['matchString',
                                                     'searchChildNamespacesToo'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'matchString': ['const',
                                                                             '&'],
                                                             'searchChildNamespacesToo': ['const']},
                                          'types': {'matchString': 'MString',
                                                    'searchChildNamespacesToo': 'bool'}},
                                         {'argInfo': {'mergeWithExisting': {'doc': 'This parameter determines what to do if the given item is already present in the list: \r  If true, the given item is unconditionally added to the end of the list without affecting the pre-existing item. \r  If false, the pre-existing item is moved from its current position to the end of the list.',
                                                                            'type': 'bool'},
                                                      'plug': {'doc': 'the plug to add ',
                                                               'type': 'MPlug'}},
                                          'args': [('plug',
                                                    'MPlug',
                                                    'in'),
                                                   ('mergeWithExisting',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'mergeWithExisting': False},
                                          'deprecated': False,
                                          'doc': '\r\nAdd the specified plug to the end of the selection list.',
                                          'inArgs': ['plug',
                                                     'mergeWithExisting'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'mergeWithExisting': ['const'],
                                                             'plug': ['const',
                                                                      '&']},
                                          'types': {'mergeWithExisting': 'bool',
                                                    'plug': 'MPlug'}},
                                         {'argInfo': {'mergeWithExisting': {'doc': 'merge new items with existing ones, or add unconditionally to end of list.',
                                                                            'type': 'bool'},
                                                      'uuid': {'doc': 'the UUID with which to look up nodes ',
                                                               'type': 'MUuid'}},
                                          'args': [('uuid',
                                                    'MUuid',
                                                    'in'),
                                                   ('mergeWithExisting',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'mergeWithExisting': False},
                                          'deprecated': False,
                                          'doc': '\r\nAdd nodes matching the UUID to the selection list.',
                                          'inArgs': ['uuid',
                                                     'mergeWithExisting'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'mergeWithExisting': [],
                                                             'uuid': ['const',
                                                                      '&']},
                                          'types': {'mergeWithExisting': 'bool',
                                                    'uuid': 'MUuid'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'clear': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nThis method empties the selection list.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'getDagPath': [{'argInfo': {'component': {'doc': 'storage for a handle for the component. This will be null if there is no component',
                                                                           'type': 'MObject'},
                                                             'dagPath': {'doc': 'storage for the dag path of the item ',
                                                                         'type': 'MDagPath'},
                                                             'index': {'doc': 'the items position in the list ',
                                                                       'type': 'uint'}},
                                                 'args': [('index',
                                                           'uint',
                                                           'in'),
                                                          ('dagPath',
                                                           'MDagPath',
                                                           'out'),
                                                          ('component',
                                                           'MObject',
                                                           'out')],
                                                 'defaults': {'component': 'MObject::kNullObj'},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the dag path and component (may be NULL) of the given element of the selection list.',
                                                 'inArgs': ['index'],
                                                 'outArgs': ['dagPath',
                                                             'component'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'component': ['&'],
                                                                    'dagPath': ['&'],
                                                                    'index': ['unsigned']},
                                                 'types': {'component': 'MObject',
                                                           'dagPath': 'MDagPath',
                                                           'index': 'uint'}}],
                                 'getDependNode': [{'argInfo': {'depNode': {'doc': 'storage for the result',
                                                                            'type': 'MObject'},
                                                                'index': {'doc': 'the items position in the list ',
                                                                          'type': 'uint'}},
                                                    'args': [('index',
                                                              'uint',
                                                              'in'),
                                                             ('depNode',
                                                              'MObject',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet a handle for the dependency node of the given element of the selection list. Returns kNullObj and kFailure if selected item does not contain a dependency node.',
                                                    'inArgs': ['index'],
                                                    'outArgs': ['depNode'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'depNode': ['&'],
                                                                       'index': ['unsigned']},
                                                    'types': {'depNode': 'MObject',
                                                              'index': 'uint'}}],
                                 'getPlug': [{'argInfo': {'index': {'doc': 'the items position in the list ',
                                                                    'type': 'uint'},
                                                          'plug': {'doc': 'storage for the result',
                                                                   'type': 'MPlug'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in'),
                                                       ('plug',
                                                        'MPlug',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the plug at the specified index of the selection list.',
                                              'inArgs': ['index'],
                                              'outArgs': ['plug'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned'],
                                                                 'plug': ['&']},
                                              'types': {'index': 'uint',
                                                        'plug': 'MPlug'}}],
                                 'getSelectionStrings': [{'argInfo': {'array': {'doc': 'storage for the returned strings',
                                                                                'type': 'MStringArray'}},
                                                          'args': [('array',
                                                                    'MStringArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGets the string representations of the items in the selection list. The strings will be in the format used by the scripting language.',
                                                          'inArgs': [],
                                                          'outArgs': ['array'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'array': ['&']},
                                                          'types': {'array': 'MStringArray'}},
                                                         {'argInfo': {'array': {'doc': 'storage for the returned strings',
                                                                                'type': 'MStringArray'},
                                                                      'index': {'doc': 'index of the element to get ',
                                                                                'type': 'uint'}},
                                                          'args': [('index',
                                                                    'uint',
                                                                    'in'),
                                                                   ('array',
                                                                    'MStringArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\r\nGets the string representation of the given item in the selection list. The strings will be in the format used by the scripting language. More than one string will be returned in the case that the item in the selection list has a component that that contains elements that are not contiguous (eg CV's 2 and 8 are selected on a surface).",
                                                          'inArgs': ['index'],
                                                          'outArgs': ['array'],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'array': ['&'],
                                                                             'index': ['unsigned']},
                                                          'types': {'array': 'MStringArray',
                                                                    'index': 'uint'}}],
                                 'hasItem': [{'argInfo': {'item': {'doc': 'The item to check for ',
                                                                   'type': 'MObject'}},
                                              'args': [('item',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines whether or not the given dependency node is in this selection list. Note that if the selection list contains a DAG node, the overloaded version of this method that takes an  MDagPath  must be used. A dag path will not compare identically to a DG node, even if they both refer to the same node.',
                                              'inArgs': ['item'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'true if the item is in this list, false otherwise',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'item': ['const',
                                                                          '&']},
                                              'types': {'item': 'MObject'}},
                                             {'argInfo': {'component': {'doc': 'the components of item to check for ',
                                                                        'type': 'MObject'},
                                                          'item': {'doc': 'the DAG object to check for ',
                                                                   'type': 'MDagPath'}},
                                              'args': [('item',
                                                        'MDagPath',
                                                        'in'),
                                                       ('component',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {'component': 'MObject::kNullObj'},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines whether or not the given DAG object is in this selection list. If the component argument is non-null, then this method will only return true of all the components of the given DAG object are on the selection list.',
                                              'inArgs': ['item',
                                                         'component'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'true if the item or component is in this list, false otherwise',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'component': ['const',
                                                                               '&'],
                                                                 'item': ['const',
                                                                          '&']},
                                              'types': {'component': 'MObject',
                                                        'item': 'MDagPath'}},
                                             {'argInfo': {'plug': {'doc': 'The plug to check for ',
                                                                   'type': 'MPlug'}},
                                              'args': [('plug',
                                                        'MPlug',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nDetermines whether or not the given plug is in this selection list.',
                                              'inArgs': ['plug'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'true if the plug is in this list, false otherwise',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                 'plug': ['const',
                                                                          '&']},
                                              'types': {'plug': 'MPlug'}}],
                                 'hasItemPartly': [{'argInfo': {'component': {'doc': 'the components of item to check for ',
                                                                              'type': 'MObject'},
                                                                'item': {'doc': 'the DAG object to check for ',
                                                                         'type': 'MDagPath'}},
                                                    'args': [('item',
                                                              'MDagPath',
                                                              'in'),
                                                             ('component',
                                                              'MObject',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nThis method differs from  hasItem  in that it determines whether or not  at least one  of the components of the the given DAG object are in this selection list. This method is only applicable when multiple components are provided.',
                                                    'inArgs': ['item',
                                                               'component'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'true if at least one of the components in this list, false otherwise',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                       'component': ['const',
                                                                                     '&'],
                                                                       'item': ['const',
                                                                                '&']},
                                                    'types': {'component': 'MObject',
                                                              'item': 'MDagPath'}}],
                                 'intersect': [{'argInfo': {'expandToLeaves': {'doc': 'If expandToLeaves is true, the two lists will be copied and grown to include leaf nodes before performing the intersection.',
                                                                               'type': 'bool'},
                                                            'other': {'doc': 'the selection list to be intersected. ',
                                                                      'type': 'MSelectionList'}},
                                                'args': [('other',
                                                          'MSelectionList',
                                                          'in'),
                                                         ('expandToLeaves',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'expandToLeaves': False},
                                                'deprecated': False,
                                                'doc': '\r\nModify this list to contain the intersection of itself and the given list.',
                                                'inArgs': ['other',
                                                           'expandToLeaves'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'expandToLeaves': [],
                                                                   'other': ['const',
                                                                             '&']},
                                                'types': {'expandToLeaves': 'bool',
                                                          'other': 'MSelectionList'}}],
                                 'isEmpty': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSpecifies whether or not the selection list contains any items.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'true if the list is empty, false otherwise.',
                                                             'qualifiers': [],
                                                             'type': 'bool'},
                                              'returnType': 'bool',
                                              'static': False,
                                              'typeQualifiers': {'ReturnStatus': ['*']},
                                              'types': {}}],
                                 'length': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nThis method returns the number of selection items in the list.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Number of items in the list',
                                                            'qualifiers': [],
                                                            'type': 'int'},
                                             'returnType': 'int',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                                 'merge': [{'argInfo': {'other': {'doc': 'the selection list to be merged. ',
                                                                  'type': 'MSelectionList'},
                                                        'strategy': {'doc': 'the merging strategy. It can be one of the the following:',
                                                                     'type': ('MSelectionList',
                                                                              'MergeStrategy')}},
                                            'args': [('other',
                                                      'MSelectionList',
                                                      'in'),
                                                     ('strategy',
                                                      ('MSelectionList',
                                                       'MergeStrategy'),
                                                      'in')],
                                            'defaults': {'strategy': ('MSelectionList',
                                                                      'MergeStrategy',
                                                                      'kMergeNormal')},
                                            'deprecated': False,
                                            'doc': '\r\nMerge the two selection lists.',
                                            'inArgs': ['other',
                                                       'strategy'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'strategy': ['const']},
                                            'types': {'other': 'MSelectionList',
                                                      'strategy': ('MSelectionList',
                                                                   'MergeStrategy')}},
                                           {'argInfo': {'component': {'doc': 'components of the Dag object to add ',
                                                                      'type': 'MObject'},
                                                        'item': {'doc': 'the dependency node to be merged. ',
                                                                 'type': 'MDagPath'},
                                                        'strategy': {'doc': 'the merging strategy. It can be one of the following:',
                                                                     'type': ('MSelectionList',
                                                                              'MergeStrategy')}},
                                            'args': [('item',
                                                      'MDagPath',
                                                      'in'),
                                                     ('component',
                                                      'MObject',
                                                      'in'),
                                                     ('strategy',
                                                      ('MSelectionList',
                                                       'MergeStrategy'),
                                                      'in')],
                                            'defaults': {'component': 'MObject::kNullObj',
                                                         'strategy': ('MSelectionList',
                                                                      'MergeStrategy',
                                                                      'kMergeNormal')},
                                            'deprecated': False,
                                            'doc': '\r\nMerge the given DAG object into the selection list.',
                                            'inArgs': ['item',
                                                       'component',
                                                       'strategy'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'component': ['const',
                                                                             '&'],
                                                               'item': ['const',
                                                                        '&'],
                                                               'strategy': ['const']},
                                            'types': {'component': 'MObject',
                                                      'item': 'MDagPath',
                                                      'strategy': ('MSelectionList',
                                                                   'MergeStrategy')}}],
                                 'remove': [{'argInfo': {'index': {'doc': 'The index of the item to be removed',
                                                                   'type': 'uint'}},
                                             'args': [('index',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nRemoves the item at the given index from the list.',
                                             'inArgs': ['index'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'index': ['unsigned']},
                                             'types': {'index': 'uint'}}],
                                 'replace': [{'argInfo': {'index': {'doc': 'The index of the item to remove from the list',
                                                                    'type': 'uint'},
                                                          'item': {'doc': 'A pointer to the replacement object ',
                                                                   'type': 'MObject'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in'),
                                                       ('item',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRemove the item at the given index in the list and replace it with the given object. The given index must not be greater than the current number of items on the list.',
                                              'inArgs': ['index', 'item'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned'],
                                                                 'item': ['const',
                                                                          '&']},
                                              'types': {'index': 'uint',
                                                        'item': 'MObject'}},
                                             {'argInfo': {'component': {'doc': 'the components of item to add ',
                                                                        'type': 'MObject'},
                                                          'index': {'doc': 'The index of the item to remove from the list',
                                                                    'type': 'uint'},
                                                          'item': {'doc': 'the new dag object to place into the list ',
                                                                   'type': 'MDagPath'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in'),
                                                       ('item',
                                                        'MDagPath',
                                                        'in'),
                                                       ('component',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {'component': 'MObject::kNullObj'},
                                              'deprecated': False,
                                              'doc': '\r\nRemove the item at the given index in the list and replace it with the given Dag item (or components). The given index must not be greater than the current number of items on the list.',
                                              'inArgs': ['index',
                                                         'item',
                                                         'component'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'component': ['const',
                                                                               '&'],
                                                                 'index': ['unsigned'],
                                                                 'item': ['const',
                                                                          '&']},
                                              'types': {'component': 'MObject',
                                                        'index': 'uint',
                                                        'item': 'MDagPath'}},
                                             {'argInfo': {'index': {'doc': 'The index of the item to remove from the list',
                                                                    'type': 'uint'},
                                                          'plug': {'doc': 'The replacement plug ',
                                                                   'type': 'MPlug'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in'),
                                                       ('plug',
                                                        'MPlug',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nRemove the item at the given index in the list and replace it with the given plug. The given index must not be greater than the current number of items on the list.',
                                              'inArgs': ['index', 'plug'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned'],
                                                                 'plug': ['const',
                                                                          '&']},
                                              'types': {'index': 'uint',
                                                        'plug': 'MPlug'}}],
                                 'toggle': [{'argInfo': {'component': {'doc': 'components of the object',
                                                                       'type': 'MObject'},
                                                         'item': {'doc': 'Dag object to be toggled ',
                                                                  'type': 'MDagPath'}},
                                             'args': [('item',
                                                       'MDagPath',
                                                       'in'),
                                                      ('component',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {'component': 'MObject::kNullObj'},
                                             'deprecated': False,
                                             'doc': '\r\nRemoves those components of the given selection item which are on the selection list, and adds those parts which are not. This method does nothing if no components are provided.',
                                             'inArgs': ['item',
                                                        'component'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'component': ['const',
                                                                              '&'],
                                                                'item': ['const',
                                                                         '&']},
                                             'types': {'component': 'MObject',
                                                       'item': 'MDagPath'}}]},
                     'pymelEnums': {'MergeStrategy': "Enum('MergeStrategy', [('mergeNormal', 0), ('kMergeNormal', 0), ('XORWithList', 1), ('kXORWithList', 1), ('removeFromList', 2), ('kRemoveFromList', 2)], multiKeys=True)"}},
  'MSelectionMask': {'enums': {'SelectionType': {'valueDocs': {'CVs': '',
                                                               'NCloths': '',
                                                               'NParticles': '',
                                                               'NRigids': '',
                                                               'PPStrokes': '',
                                                               'UVLocators': '',
                                                               'XYZLocators': '',
                                                               'animAny': '',
                                                               'animCurves': '',
                                                               'animInTangents': '',
                                                               'animKeyframes': '',
                                                               'animMask': '',
                                                               'animOutTangents': '',
                                                               'cameras': '',
                                                               'clusters': '',
                                                               'collisionModels': '',
                                                               'componentsMask': '',
                                                               'curveKnots': '',
                                                               'curveParmPoints': '',
                                                               'curves': '',
                                                               'curvesOnSurfaces': '',
                                                               'dynamicConstraints': '',
                                                               'edges': '',
                                                               'editPoints': '',
                                                               'emitters': '',
                                                               'facets': '',
                                                               'fields': '',
                                                               'fluids': '',
                                                               'follicles': '',
                                                               'guideLines': '',
                                                               'hairSystems': '',
                                                               'handles': '',
                                                               'hulls': '',
                                                               'ikEndEffectors': '',
                                                               'ikHandles': '',
                                                               'isoparms': '',
                                                               'jointPivots': '',
                                                               'joints': '',
                                                               'kSelectAnimAny': '',
                                                               'kSelectAnimCurves': '',
                                                               'kSelectAnimInTangents': '',
                                                               'kSelectAnimKeyframes': '',
                                                               'kSelectAnimMask': '',
                                                               'kSelectAnimOutTangents': '',
                                                               'kSelectCVs': '',
                                                               'kSelectCameras': '',
                                                               'kSelectClusters': '',
                                                               'kSelectCollisionModels': '',
                                                               'kSelectComponentsMask': '',
                                                               'kSelectCurveKnots': '',
                                                               'kSelectCurveParmPoints': '',
                                                               'kSelectCurves': '',
                                                               'kSelectCurvesOnSurfaces': '',
                                                               'kSelectDynamicConstraints': '',
                                                               'kSelectEdges': '',
                                                               'kSelectEditPoints': '',
                                                               'kSelectEmitters': '',
                                                               'kSelectFacets': '',
                                                               'kSelectFields': '',
                                                               'kSelectFluids': '',
                                                               'kSelectFollicles': '',
                                                               'kSelectGuideLines': '',
                                                               'kSelectHairSystems': '',
                                                               'kSelectHandles': '',
                                                               'kSelectHulls': '',
                                                               'kSelectIkEndEffectors': '',
                                                               'kSelectIkHandles': '',
                                                               'kSelectIsoparms': '',
                                                               'kSelectJointPivots': '',
                                                               'kSelectJoints': '',
                                                               'kSelectLatticePoints': '',
                                                               'kSelectLattices': '',
                                                               'kSelectLights': '',
                                                               'kSelectLocalAxis': '',
                                                               'kSelectLocators': '',
                                                               'kSelectManipulators': '',
                                                               'kSelectMeshComponents': '',
                                                               'kSelectMeshEdges': '',
                                                               'kSelectMeshFaces': '',
                                                               'kSelectMeshFreeEdges': '',
                                                               'kSelectMeshLines': '',
                                                               'kSelectMeshUVs': '',
                                                               'kSelectMeshVerts': '',
                                                               'kSelectMeshes': '',
                                                               'kSelectNCloths': '',
                                                               'kSelectNParticles': '',
                                                               'kSelectNRigids': '',
                                                               'kSelectNurbsCurves': '',
                                                               'kSelectNurbsSurfaces': '',
                                                               'kSelectObjectGroups': '',
                                                               'kSelectObjectsMask': '',
                                                               'kSelectOrientationLocators': '',
                                                               'kSelectPPStrokes': '',
                                                               'kSelectParticleShapes': '',
                                                               'kSelectParticles': '',
                                                               'kSelectPivots': '',
                                                               'kSelectPointsForGravity': '',
                                                               'kSelectPointsOnCurvesForGravity': '',
                                                               'kSelectPointsOnSurfacesForGravity': '',
                                                               'kSelectRigidBodies': '',
                                                               'kSelectRigidConstraints': '',
                                                               'kSelectRotatePivots': '',
                                                               'kSelectScalePivots': '',
                                                               'kSelectSculpts': '',
                                                               'kSelectSelectHandles': '',
                                                               'kSelectSketchPlanes': '',
                                                               'kSelectSprings': '',
                                                               'kSelectSubdiv': '',
                                                               'kSelectSubdivMeshEdges': '',
                                                               'kSelectSubdivMeshFaces': '',
                                                               'kSelectSubdivMeshMaps': '',
                                                               'kSelectSubdivMeshPoints': '',
                                                               'kSelectSurfaceEdge': '',
                                                               'kSelectSurfaceKnots': '',
                                                               'kSelectSurfaceParmPoints': '',
                                                               'kSelectSurfaceRange': '',
                                                               'kSelectSurfaces': '',
                                                               'kSelectTemplates': '',
                                                               'kSelectTextures': '',
                                                               'kSelectUVLocators': '',
                                                               'kSelectVertices': '',
                                                               'kSelectXYZLocators': '',
                                                               'latticePoints': '',
                                                               'lattices': '',
                                                               'lights': '',
                                                               'localAxis': '',
                                                               'locators': '',
                                                               'manipulators': '',
                                                               'meshComponents': '',
                                                               'meshEdges': '',
                                                               'meshFaces': '',
                                                               'meshFreeEdges': '',
                                                               'meshLines': '',
                                                               'meshUVs': '',
                                                               'meshVerts': '',
                                                               'meshes': '',
                                                               'nurbsCurves': '',
                                                               'nurbsSurfaces': '',
                                                               'objectGroups': '',
                                                               'objectsMask': '',
                                                               'orientationLocators': '',
                                                               'particleShapes': '',
                                                               'particles': '',
                                                               'pivots': '',
                                                               'pointsForGravity': '',
                                                               'pointsOnCurvesForGravity': '',
                                                               'pointsOnSurfacesForGravity': '',
                                                               'rigidBodies': '',
                                                               'rigidConstraints': '',
                                                               'rotatePivots': '',
                                                               'scalePivots': '',
                                                               'sculpts': '',
                                                               'selectHandles': '',
                                                               'sketchPlanes': '',
                                                               'springs': '',
                                                               'subdiv': '',
                                                               'subdivMeshEdges': '',
                                                               'subdivMeshFaces': '',
                                                               'subdivMeshMaps': '',
                                                               'subdivMeshPoints': '',
                                                               'surfaceEdge': '',
                                                               'surfaceKnots': '',
                                                               'surfaceParmPoints': '',
                                                               'surfaceRange': '',
                                                               'surfaces': '',
                                                               'templates': '',
                                                               'textures': '',
                                                               'vertices': ''},
                                                 'values': "Enum('SelectionType', {'kSelectHandles': 0, 'kSelectLocalAxis': 1, 'kSelectIkHandles': 2, 'kSelectIkEndEffectors': 3, 'kSelectJoints': 4, 'kSelectLights': 5, 'kSelectCameras': 6, 'kSelectLattices': 7, 'kSelectClusters': 8, 'kSelectSculpts': 9, 'kSelectNurbsCurves': 10, 'kSelectNurbsSurfaces': 11, 'kSelectMeshes': 12, 'kSelectSubdiv': 13, 'kSelectSketchPlanes': 14, 'kSelectParticleShapes': 15, 'kSelectEmitters': 16, 'kSelectFields': 17, 'kSelectSprings': 18, 'kSelectRigidBodies': 19, 'kSelectRigidConstraints': 20, 'kSelectCollisionModels': 21, 'kSelectXYZLocators': 22, 'kSelectOrientationLocators': 23, 'kSelectUVLocators': 24, 'kSelectTextures': 25, 'kSelectCurves': 26, 'kSelectSurfaces': 27, 'kSelectLocators': 28, 'kSelectObjectsMask': 29, 'kSelectCVs': 30, 'kSelectHulls': 31, 'kSelectEditPoints': 32, 'kSelectMeshVerts': 33, 'kSelectMeshEdges': 34, 'kSelectMeshFreeEdges': 35, 'kSelectMeshFaces': 36, 'kSelectSubdivMeshPoints': 37, 'kSelectSubdivMeshEdges': 38, 'kSelectSubdivMeshFaces': 39, 'kSelectMeshUVs': 40, 'kSelectVertices': 41, 'kSelectEdges': 42, 'kSelectFacets': 43, 'kSelectMeshLines': 44, 'kSelectMeshComponents': 45, 'kSelectCurveParmPoints': 46, 'kSelectCurveKnots': 47, 'kSelectSurfaceParmPoints': 48, 'kSelectSurfaceKnots': 49, 'kSelectSurfaceRange': 50, 'kSelectSurfaceEdge': 51, 'kSelectIsoparms': 52, 'kSelectCurvesOnSurfaces': 53, 'kSelectPPStrokes': 54, 'kSelectLatticePoints': 55, 'kSelectParticles': 56, 'kSelectJointPivots': 57, 'kSelectScalePivots': 58, 'kSelectRotatePivots': 59, 'kSelectPivots': 60, 'kSelectSelectHandles': 61, 'kSelectComponentsMask': 62, 'kSelectAnimCurves': 63, 'kSelectAnimKeyframes': 64, 'kSelectAnimInTangents': 65, 'kSelectAnimOutTangents': 66, 'kSelectAnimMask': 67, 'kSelectAnimAny': 68, 'kSelectTemplates': 69, 'kSelectManipulators': 70, 'kSelectGuideLines': 71, 'kSelectPointsForGravity': 72, 'kSelectPointsOnCurvesForGravity': 73, 'kSelectPointsOnSurfacesForGravity': 74, 'kSelectObjectGroups': 75, 'kSelectSubdivMeshMaps': 76, 'kSelectFluids': 77, 'kSelectHairSystems': 78, 'kSelectFollicles': 79, 'kSelectNCloths': 80, 'kSelectNRigids': 81, 'kSelectDynamicConstraints': 82, 'kSelectNParticles': 83})"}},
                     'methods': {'addMask': [{'argInfo': {'selType': {'doc': 'the selection type to add',
                                                                      'type': ('MSelectionMask',
                                                                               'SelectionType')}},
                                              'args': [('selType',
                                                        ('MSelectionMask',
                                                         'SelectionType'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nAdd the specified selection type to this mask.',
                                              'inArgs': ['selType'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'selType': []},
                                              'types': {'selType': ('MSelectionMask',
                                                                    'SelectionType')}}],
                                 'deregisterSelectionType': [{'argInfo': {'selTypeName': {'doc': 'Name of the selection type.',
                                                                                          'type': 'MString'}},
                                                              'args': [('selTypeName',
                                                                        'MString',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nUnregisters a previously registered selection type.',
                                                              'inArgs': ['selTypeName'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': ' true The selection type was successfully unregistered.  false Failed to unregister the selection type.   ',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': True,
                                                              'typeQualifiers': {'selTypeName': ['const',
                                                                                                 '&']},
                                                              'types': {'selTypeName': 'MString'}}],
                                 'getSelectionTypePriority': [{'argInfo': {'selTypeName': {'doc': 'Name of the selection type.',
                                                                                           'type': 'MString'}},
                                                               'args': [('selTypeName',
                                                                         'MString',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nGets the selection priority corresponding to a given selection type.',
                                                               'inArgs': ['selTypeName'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The selection priority corresponding to a given selection type. return -1 if there is no select type named selTypeName. ',
                                                                              'qualifiers': [],
                                                                              'type': 'int'},
                                                               'returnType': 'int',
                                                               'static': True,
                                                               'typeQualifiers': {'selTypeName': ['const',
                                                                                                  '&']},
                                                               'types': {'selTypeName': 'MString'}}],
                                 'intersects': [{'argInfo': {'selType': {'doc': 'the selection type to test ',
                                                                         'type': ('MSelectionMask',
                                                                                  'SelectionType')}},
                                                 'args': [('selType',
                                                           ('MSelectionMask',
                                                            'SelectionType'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if the specified selection type is contained within this selection mask.',
                                                 'inArgs': ['selType'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true the specified selection type is contained in this mask  false the specified selection type is not in this mask  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'selType': []},
                                                 'types': {'selType': ('MSelectionMask',
                                                                       'SelectionType')}},
                                                {'argInfo': {'mask': {'doc': 'the selection mask to test ',
                                                                      'type': 'MSelectionMask'}},
                                                 'args': [('mask',
                                                           'MSelectionMask',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nReturns true if the specified selection mask is contained within this selection mask.',
                                                 'inArgs': ['mask'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': ' true the specified selection mask is contained in this mask  false the specified selection mask is not in this mask  ',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                    'mask': ['&']},
                                                 'types': {'mask': 'MSelectionMask'}}],
                                 'registerSelectionType': [{'argInfo': {'priority': {'doc': "Priority of the selection type,see 'selectPriority' command.",
                                                                                     'type': 'int'},
                                                                        'selTypeName': {'doc': 'Name of the selection type. ',
                                                                                        'type': 'MString'}},
                                                            'args': [('selTypeName',
                                                                      'MString',
                                                                      'in'),
                                                                     ('priority',
                                                                      'int',
                                                                      'in')],
                                                            'defaults': {'priority': 0},
                                                            'deprecated': False,
                                                            'doc': '\r\nRegisters a new selection type. It is perfectly legal for 2 plug-ins to register the same selection type. Currently we use the registration count. The selection type is deleted only when  deregisterSelectionType()  as been called the same number of times as this function -  registerSelectionType() .',
                                                            'inArgs': ['selTypeName',
                                                                       'priority'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': ' true The selection type was successfully registered.  false Failed to register the selection type.   ',
                                                                           'qualifiers': [],
                                                                           'type': 'bool'},
                                                            'returnType': 'bool',
                                                            'static': True,
                                                            'typeQualifiers': {'priority': [],
                                                                               'selTypeName': ['const',
                                                                                               '&']},
                                                            'types': {'priority': 'int',
                                                                      'selTypeName': 'MString'}}],
                                 'setMask': [{'argInfo': {'selType': {'doc': 'the selection type to be set',
                                                                      'type': ('MSelectionMask',
                                                                               'SelectionType')}},
                                              'args': [('selType',
                                                        ('MSelectionMask',
                                                         'SelectionType'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets the selection mask to the specified selection type.',
                                              'inArgs': ['selType'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'selType': []},
                                              'types': {'selType': ('MSelectionMask',
                                                                    'SelectionType')}},
                                             {'argInfo': {'mask': {'doc': 'the mask with the selection type to be set',
                                                                   'type': 'MSelectionMask'}},
                                              'args': [('mask',
                                                        'MSelectionMask',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets the selection type for this mask to the selection type of the specified mask.',
                                              'inArgs': ['mask'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'mask': ['&']},
                                              'types': {'mask': 'MSelectionMask'}}]},
                     'pymelEnums': {'SelectionType': "Enum('SelectionType', [('handles', 0), ('kSelectHandles', 0), ('localAxis', 1), ('kSelectLocalAxis', 1), ('ikHandles', 2), ('kSelectIkHandles', 2), ('ikEndEffectors', 3), ('kSelectIkEndEffectors', 3), ('joints', 4), ('kSelectJoints', 4), ('lights', 5), ('kSelectLights', 5), ('cameras', 6), ('kSelectCameras', 6), ('lattices', 7), ('kSelectLattices', 7), ('clusters', 8), ('kSelectClusters', 8), ('sculpts', 9), ('kSelectSculpts', 9), ('nurbsCurves', 10), ('kSelectNurbsCurves', 10), ('nurbsSurfaces', 11), ('kSelectNurbsSurfaces', 11), ('meshes', 12), ('kSelectMeshes', 12), ('subdiv', 13), ('kSelectSubdiv', 13), ('sketchPlanes', 14), ('kSelectSketchPlanes', 14), ('particleShapes', 15), ('kSelectParticleShapes', 15), ('emitters', 16), ('kSelectEmitters', 16), ('fields', 17), ('kSelectFields', 17), ('springs', 18), ('kSelectSprings', 18), ('rigidBodies', 19), ('kSelectRigidBodies', 19), ('rigidConstraints', 20), ('kSelectRigidConstraints', 20), ('collisionModels', 21), ('kSelectCollisionModels', 21), ('XYZLocators', 22), ('kSelectXYZLocators', 22), ('orientationLocators', 23), ('kSelectOrientationLocators', 23), ('UVLocators', 24), ('kSelectUVLocators', 24), ('textures', 25), ('kSelectTextures', 25), ('curves', 26), ('kSelectCurves', 26), ('surfaces', 27), ('kSelectSurfaces', 27), ('locators', 28), ('kSelectLocators', 28), ('objectsMask', 29), ('kSelectObjectsMask', 29), ('CVs', 30), ('kSelectCVs', 30), ('hulls', 31), ('kSelectHulls', 31), ('editPoints', 32), ('kSelectEditPoints', 32), ('meshVerts', 33), ('kSelectMeshVerts', 33), ('meshEdges', 34), ('kSelectMeshEdges', 34), ('meshFreeEdges', 35), ('kSelectMeshFreeEdges', 35), ('meshFaces', 36), ('kSelectMeshFaces', 36), ('subdivMeshPoints', 37), ('kSelectSubdivMeshPoints', 37), ('subdivMeshEdges', 38), ('kSelectSubdivMeshEdges', 38), ('subdivMeshFaces', 39), ('kSelectSubdivMeshFaces', 39), ('meshUVs', 40), ('kSelectMeshUVs', 40), ('vertices', 41), ('kSelectVertices', 41), ('edges', 42), ('kSelectEdges', 42), ('facets', 43), ('kSelectFacets', 43), ('meshLines', 44), ('kSelectMeshLines', 44), ('meshComponents', 45), ('kSelectMeshComponents', 45), ('curveParmPoints', 46), ('kSelectCurveParmPoints', 46), ('curveKnots', 47), ('kSelectCurveKnots', 47), ('surfaceParmPoints', 48), ('kSelectSurfaceParmPoints', 48), ('surfaceKnots', 49), ('kSelectSurfaceKnots', 49), ('surfaceRange', 50), ('kSelectSurfaceRange', 50), ('surfaceEdge', 51), ('kSelectSurfaceEdge', 51), ('isoparms', 52), ('kSelectIsoparms', 52), ('curvesOnSurfaces', 53), ('kSelectCurvesOnSurfaces', 53), ('PPStrokes', 54), ('kSelectPPStrokes', 54), ('latticePoints', 55), ('kSelectLatticePoints', 55), ('particles', 56), ('kSelectParticles', 56), ('jointPivots', 57), ('kSelectJointPivots', 57), ('scalePivots', 58), ('kSelectScalePivots', 58), ('rotatePivots', 59), ('kSelectRotatePivots', 59), ('pivots', 60), ('kSelectPivots', 60), ('selectHandles', 61), ('kSelectSelectHandles', 61), ('componentsMask', 62), ('kSelectComponentsMask', 62), ('animCurves', 63), ('kSelectAnimCurves', 63), ('animKeyframes', 64), ('kSelectAnimKeyframes', 64), ('animInTangents', 65), ('kSelectAnimInTangents', 65), ('animOutTangents', 66), ('kSelectAnimOutTangents', 66), ('animMask', 67), ('kSelectAnimMask', 67), ('animAny', 68), ('kSelectAnimAny', 68), ('templates', 69), ('kSelectTemplates', 69), ('manipulators', 70), ('kSelectManipulators', 70), ('guideLines', 71), ('kSelectGuideLines', 71), ('pointsForGravity', 72), ('kSelectPointsForGravity', 72), ('pointsOnCurvesForGravity', 73), ('kSelectPointsOnCurvesForGravity', 73), ('pointsOnSurfacesForGravity', 74), ('kSelectPointsOnSurfacesForGravity', 74), ('objectGroups', 75), ('kSelectObjectGroups', 75), ('subdivMeshMaps', 76), ('kSelectSubdivMeshMaps', 76), ('fluids', 77), ('kSelectFluids', 77), ('hairSystems', 78), ('kSelectHairSystems', 78), ('follicles', 79), ('kSelectFollicles', 79), ('NCloths', 80), ('kSelectNCloths', 80), ('NRigids', 81), ('kSelectNRigids', 81), ('dynamicConstraints', 82), ('kSelectDynamicConstraints', 82), ('NParticles', 83), ('kSelectNParticles', 83)], multiKeys=True)"}},
  'MSetAttrEdit': {'enums': {},
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'editType': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nVirtual method used to return the edit type of this edit, which is  MEdit::kSetAttrEdit .',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MEdit::kSetAttrEdit',
                                                            'qualifiers': [],
                                                            'type': ('MEdit',
                                                                     'EditType')},
                                             'returnType': ('MEdit',
                                                            'EditType'),
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}],
                               'plug': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the plug that was set for this edit. The plug can only be returned when the related reference or assembly is loaded and the edit was made from the top-level. Otherwise, only the plug name string can be queried, using  MSetAttrEdit::plugName .',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The plug that was set for this edit',
                                                        'qualifiers': [],
                                                        'type': 'MPlug'},
                                         'returnType': 'MPlug',
                                         'static': False,
                                         'typeQualifiers': {'ReturnStatus': ['*']},
                                         'types': {}}],
                               'plugName': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nReturns the name of the plug that was set for this edit.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The name of the plug that was set for this edit',
                                                            'qualifiers': [],
                                                            'type': 'MString'},
                                             'returnType': 'MString',
                                             'static': False,
                                             'typeQualifiers': {'ReturnStatus': ['*']},
                                             'types': {}}]},
                   'pymelEnums': {}},
  'MSpace': {'enums': {'Space': {'valueDocs': {'invalid': 'Invalid value.',
                                               'kInvalid': 'Invalid value.',
                                               'kLast': 'Last value, used for counting.',
                                               'kObject': 'Same as pre-transform space.',
                                               'kPostTransform': 'Post-transform matrix (world) space.',
                                               'kPreTransform': 'Pre-transform matrix (geometry).',
                                               'kTransform': 'Transform matrix (relative) space.',
                                               'kWorld': 'transform in world space.',
                                               'last': 'Last value, used for counting.',
                                               'object': 'Same as pre-transform space.',
                                               'postTransform': 'Post-transform matrix (world) space.',
                                               'preTransform': 'Pre-transform matrix (geometry).',
                                               'transform': 'Transform matrix (relative) space.',
                                               'world': 'transform in world space.'},
                                 'values': "Enum('Space', [('kInvalid', 0), ('kTransform', 1), ('kPreTransform', 2), ('kObject', 2), ('kPostTransform', 3), ('kWorld', 4), ('kLast', 5)], multiKeys=True)"}},
             'methods': {},
             'pymelEnums': {'Space': "Enum('Space', {'invalid': 0, 'transform': 1, 'preTransform': 2, 'object': 3, 'world': 4, 'last': 5})"}},
  'MStreamUtils': {'enums': {},
                   'methods': {'readChar': [{'argInfo': {'binary': {'doc': 'if true the value appears in the input stream in binary form, otherwise it is in string form',
                                                                    'type': 'bool'},
                                                         'in': {'doc': 'the input istream ',
                                                                'type': ('std',
                                                                         'istream')},
                                                         'value': {'doc': 'where the input is stored ',
                                                                   'type': 'char'}},
                                             'args': [('in',
                                                       ('std',
                                                        'istream'),
                                                       'in'),
                                                      ('value',
                                                       'char',
                                                       'out'),
                                                      ('binary',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'binary': False},
                                             'deprecated': False,
                                             'doc': '\nThis method is used to read a "char" binary value from an istream.',
                                             'inArgs': ['in', 'binary'],
                                             'outArgs': ['value'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'binary': [],
                                                                'in': ['&'],
                                                                'value': ['&']},
                                             'types': {'binary': 'bool',
                                                       'in': ('std',
                                                              'istream'),
                                                       'value': 'char'}}],
                               'readCharBuffer': [{'argInfo': {'binary': {'doc': 'if true the value appears in the input stream in binary form, otherwise it is in string form',
                                                                          'type': 'bool'},
                                                               'in': {'doc': 'the input istream ',
                                                                      'type': ('std',
                                                                               'istream')},
                                                               'length': {'doc': 'number of characters to read ',
                                                                          'type': 'uint'},
                                                               'value': {'doc': 'where the input is stored ',
                                                                         'type': 'char'}},
                                                   'args': [('in',
                                                             ('std',
                                                              'istream'),
                                                             'in'),
                                                            ('value',
                                                             'char',
                                                             'out'),
                                                            ('length',
                                                             'uint',
                                                             'in'),
                                                            ('binary',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {'binary': False},
                                                   'deprecated': False,
                                                   'doc': '\nThis method is used to read a character string (char*) from an istream.',
                                                   'inArgs': ['in',
                                                              'length',
                                                              'binary'],
                                                   'outArgs': ['value'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': True,
                                                   'typeQualifiers': {'binary': [],
                                                                      'in': ['&'],
                                                                      'length': ['unsigned'],
                                                                      'value': ['*&']},
                                                   'types': {'binary': 'bool',
                                                             'in': ('std',
                                                                    'istream'),
                                                             'length': 'uint',
                                                             'value': 'char'}}],
                               'readDouble': [{'argInfo': {'binary': {'doc': 'if true the value appears in the input stream in binary form, otherwise it is in string form',
                                                                      'type': 'bool'},
                                                           'in': {'doc': 'the input istream ',
                                                                  'type': ('std',
                                                                           'istream')},
                                                           'value': {'doc': 'where the input is stored ',
                                                                     'type': 'double'}},
                                               'args': [('in',
                                                         ('std',
                                                          'istream'),
                                                         'in'),
                                                        ('value',
                                                         'double',
                                                         'out'),
                                                        ('binary',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'binary': False},
                                               'deprecated': False,
                                               'doc': '\nThis method is used to read a "double" binary value from an istream.',
                                               'inArgs': ['in', 'binary'],
                                               'outArgs': ['value'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'binary': [],
                                                                  'in': ['&'],
                                                                  'value': ['&']},
                                               'types': {'binary': 'bool',
                                                         'in': ('std',
                                                                'istream'),
                                                         'value': 'double'}}],
                               'readFloat': [{'argInfo': {'binary': {'doc': 'if true the value appears in the input stream in binary form, otherwise it is in string form',
                                                                     'type': 'bool'},
                                                          'in': {'doc': 'the input istream ',
                                                                 'type': ('std',
                                                                          'istream')},
                                                          'value': {'doc': 'where the input is stored ',
                                                                    'type': 'float'}},
                                              'args': [('in',
                                                        ('std',
                                                         'istream'),
                                                        'in'),
                                                       ('value',
                                                        'float',
                                                        'out'),
                                                       ('binary',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'binary': False},
                                              'deprecated': False,
                                              'doc': '\nThis method is used to read a "float" binary value from an istream.',
                                              'inArgs': ['in', 'binary'],
                                              'outArgs': ['value'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'binary': [],
                                                                 'in': ['&'],
                                                                 'value': ['&']},
                                              'types': {'binary': 'bool',
                                                        'in': ('std',
                                                               'istream'),
                                                        'value': 'float'}}],
                               'readInt': [{'argInfo': {'binary': {'doc': 'if true the value appears in the input stream in binary form, otherwise it is in string form',
                                                                   'type': 'bool'},
                                                        'in': {'doc': 'the input istream ',
                                                               'type': ('std',
                                                                        'istream')},
                                                        'value': {'doc': 'where the input is stored ',
                                                                  'type': 'int'}},
                                            'args': [('in',
                                                      ('std',
                                                       'istream'),
                                                      'in'),
                                                     ('value',
                                                      'int',
                                                      'out'),
                                                     ('binary',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'binary': False},
                                            'deprecated': False,
                                            'doc': '\nThis method is used to read a "int" binary value from an istream.',
                                            'inArgs': ['in', 'binary'],
                                            'outArgs': ['value'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': True,
                                            'typeQualifiers': {'binary': [],
                                                               'in': ['&'],
                                                               'value': ['&']},
                                            'types': {'binary': 'bool',
                                                      'in': ('std',
                                                             'istream'),
                                                      'value': 'int'}}],
                               'stdErrorStream': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nThis method returns the cerr ostream. \n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['&'],
                                                                  'type': ('std',
                                                                           'ostream')},
                                                   'returnType': ('std',
                                                                  'ostream'),
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                               'stdOutStream': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nThis method returns the cout ostream. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['&'],
                                                                'type': ('std',
                                                                         'ostream')},
                                                 'returnType': ('std',
                                                                'ostream'),
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'writeChar': [{'argInfo': {'binary': {'doc': 'If true, the byte(s) of value are written out. If false, the string representation is written out.',
                                                                     'type': 'bool'},
                                                          'out': {'doc': 'the output ostream ',
                                                                  'type': ('std',
                                                                           'ostream')},
                                                          'value': {'doc': 'value to write out ',
                                                                    'type': 'char'}},
                                              'args': [('out',
                                                        ('std',
                                                         'ostream'),
                                                        'in'),
                                                       ('value',
                                                        'char',
                                                        'in'),
                                                       ('binary',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'binary': False},
                                              'deprecated': False,
                                              'doc': '\nThis method is used to write out a "char" value to an ostream.',
                                              'inArgs': ['out',
                                                         'value',
                                                         'binary'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {'binary': [],
                                                                 'out': ['&'],
                                                                 'value': ['const']},
                                              'types': {'binary': 'bool',
                                                        'out': ('std',
                                                                'ostream'),
                                                        'value': 'char'}}],
                               'writeCharBuffer': [{'argInfo': {'binary': {'doc': 'If true, the byte(s) of the value string are written out. If false, the string representation is written out.',
                                                                           'type': 'bool'},
                                                                'out': {'doc': 'the output ostream ',
                                                                        'type': ('std',
                                                                                 'ostream')},
                                                                'value': {'doc': 'string to write out ',
                                                                          'type': 'char'}},
                                                    'args': [('out',
                                                              ('std',
                                                               'ostream'),
                                                              'in'),
                                                             ('value',
                                                              'char',
                                                              'in'),
                                                             ('binary',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {'binary': False},
                                                    'deprecated': False,
                                                    'doc': '\nThis method is used to write out a mull-terminated string (const char*) to an ostream.',
                                                    'inArgs': ['out',
                                                               'value',
                                                               'binary'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': True,
                                                    'typeQualifiers': {'binary': [],
                                                                       'out': ['&'],
                                                                       'value': ['const',
                                                                                 '*']},
                                                    'types': {'binary': 'bool',
                                                              'out': ('std',
                                                                      'ostream'),
                                                              'value': 'char'}}],
                               'writeDouble': [{'argInfo': {'binary': {'doc': 'If true, the byte(s) of value are written out. If false, the string representation is written out.',
                                                                       'type': 'bool'},
                                                            'out': {'doc': 'the output ostream ',
                                                                    'type': ('std',
                                                                             'ostream')},
                                                            'value': {'doc': 'value to write out ',
                                                                      'type': 'double'}},
                                                'args': [('out',
                                                          ('std',
                                                           'ostream'),
                                                          'in'),
                                                         ('value',
                                                          'double',
                                                          'in'),
                                                         ('binary',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'binary': False},
                                                'deprecated': False,
                                                'doc': '\nThis method is used to write out a "double" value to an ostream.',
                                                'inArgs': ['out',
                                                           'value',
                                                           'binary'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {'binary': [],
                                                                   'out': ['&'],
                                                                   'value': ['const']},
                                                'types': {'binary': 'bool',
                                                          'out': ('std',
                                                                  'ostream'),
                                                          'value': 'double'}}],
                               'writeFloat': [{'argInfo': {'binary': {'doc': 'If true, the byte(s) of value are written out. If false, the string representation is written out.',
                                                                      'type': 'bool'},
                                                           'out': {'doc': 'the output ostream ',
                                                                   'type': ('std',
                                                                            'ostream')},
                                                           'value': {'doc': 'value to write out ',
                                                                     'type': 'float'}},
                                               'args': [('out',
                                                         ('std',
                                                          'ostream'),
                                                         'in'),
                                                        ('value',
                                                         'float',
                                                         'in'),
                                                        ('binary',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'binary': False},
                                               'deprecated': False,
                                               'doc': '\nThis method is used to write out a "float" value to an ostream.',
                                               'inArgs': ['out',
                                                          'value',
                                                          'binary'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'binary': [],
                                                                  'out': ['&'],
                                                                  'value': ['const']},
                                               'types': {'binary': 'bool',
                                                         'out': ('std',
                                                                 'ostream'),
                                                         'value': 'float'}}],
                               'writeInt': [{'argInfo': {'binary': {'doc': 'If true, the byte(s) of value are written out. If false, the string representation is written out.',
                                                                    'type': 'bool'},
                                                         'out': {'doc': 'the output ostream ',
                                                                 'type': ('std',
                                                                          'ostream')},
                                                         'value': {'doc': 'value to write out ',
                                                                   'type': 'int'}},
                                             'args': [('out',
                                                       ('std',
                                                        'ostream'),
                                                       'in'),
                                                      ('value',
                                                       'int',
                                                       'in'),
                                                      ('binary',
                                                       'bool',
                                                       'in')],
                                             'defaults': {'binary': False},
                                             'deprecated': False,
                                             'doc': '\nThis method is used to write out a "int" value to an ostream.',
                                             'inArgs': ['out',
                                                        'value',
                                                        'binary'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': True,
                                             'typeQualifiers': {'binary': [],
                                                                'out': ['&'],
                                                                'value': ['const']},
                                             'types': {'binary': 'bool',
                                                       'out': ('std',
                                                               'ostream'),
                                                       'value': 'int'}}]},
                   'pymelEnums': {}},
  'MSwatchRenderBase': {'enums': {},
                        'invertibles': [('setRenderQuality',
                                         'renderQuality')],
                        'methods': {'cancelCurrentSwatchRender': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\nThe method cancels the swatch which is being rendered in parallel, and push the swatch render item back to the render queue after.',
                                                                   'inArgs': [],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': True,
                                                                   'typeQualifiers': {},
                                                                   'types': {}}],
                                    'cancelParallelRendering': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nMethod to cancel the parallel rendering. The derived classes should provide the implementation accordingly if required. \n',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                    'doIteration': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nMethod called from the  MSwatchRenderRegister  for generation of swatch image. The doIteration function is called repeatedly (during idle events) until it returns true. Using this swatch image can be generated in stages.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'enableSwatchRender': [{'argInfo': {'enable': {'doc': 'Flag indicating if swatch rendering should be enabled or disabled. ',
                                                                                   'type': 'bool'}},
                                                            'args': [('enable',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nEnable/disable swatch rendering.',
                                                            'inArgs': ['enable'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': True,
                                                            'typeQualifiers': {'enable': []},
                                                            'types': {'enable': 'bool'}}],
                                    'finishParallelRender': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nMethod to update the swatch image when the parallel rendering is finished.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                    'image': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nThis method returns the the render swatch as an image. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['&'],
                                                              'type': 'MImage'},
                                               'returnType': 'MImage',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'node': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nThis method returns the node that is used to compute the swatch. \n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'renderParallel': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nMethod indicates if the swatch is rendered parallel.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'renderQuality': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nReturns the quality in which the swatch will be rendered.',
                                                       'inArgs': [],
                                                       'inverse': ('setRenderQuality',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'int'},
                                                       'returnType': 'int',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                    'resolution': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nThis method returns the expected resolution of the swatch \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'setRenderQuality': [{'argInfo': {'quality': {'doc': 'The quality to render the swatch ',
                                                                                  'type': 'int'}},
                                                          'args': [('quality',
                                                                    'int',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nMethod to set the render quality in which the swatch will be rendered. The derived classes should make sure that the larger the number is set, the better quality is applied.',
                                                          'inArgs': ['quality'],
                                                          'inverse': ('renderQuality',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'quality': []},
                                                          'types': {'quality': 'int'}}],
                                    'swatchNode': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nThis method returns the node for which the swatch is required to be generated. \n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'MObject'},
                                                    'returnType': 'MObject',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                        'pymelEnums': {},
                        'pymelMethods': {'renderQuality': 'getRenderQuality'}},
  'MSwatchRenderRegister': {'enums': {},
                            'methods': {'registerSwatchRender': [{'argInfo': {'fnPtr': {'doc': 'Pointer to a function which takes the node and resolution of the swatch image to be generated and creates the swatch generator object.',
                                                                                        'type': 'MSwatchRenderCreatorFnPtr'},
                                                                              'swatchGenName': {'doc': 'A name to identify the swatch generator. Should match the name used in the "swatch" classfication string of the nodes',
                                                                                                'type': 'MString'}},
                                                                  'args': [('swatchGenName',
                                                                            'MString',
                                                                            'in'),
                                                                           ('fnPtr',
                                                                            'MSwatchRenderCreatorFnPtr',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nregisters a new swatch generator creation function by name. \r\n',
                                                                  'inArgs': ['swatchGenName',
                                                                             'fnPtr'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': True,
                                                                  'typeQualifiers': {'fnPtr': [],
                                                                                     'swatchGenName': []},
                                                                  'types': {'fnPtr': 'MSwatchRenderCreatorFnPtr',
                                                                            'swatchGenName': 'MString'}}],
                                        'unregisterSwatchRender': [{'argInfo': {'swatchGen': {'doc': 'The name which was used for the swatch generator. Should match the name used during registration.',
                                                                                              'type': 'MString'}},
                                                                    'args': [('swatchGen',
                                                                              'MString',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nremoves the previously registered swatch generator \r\n',
                                                                    'inArgs': ['swatchGen'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': True,
                                                                    'typeQualifiers': {'swatchGen': []},
                                                                    'types': {'swatchGen': 'MString'}}]},
                            'pymelEnums': {}},
  'MSyntax': {'enums': {'MArgType': {'valueDocs': {'angle': '',
                                                   'boolean': '',
                                                   'distance': '',
                                                   'double': '',
                                                   'invalidArgType': '',
                                                   'kAngle': '',
                                                   'kBoolean': '',
                                                   'kDistance': '',
                                                   'kDouble': '',
                                                   'kInvalidArgType': '',
                                                   'kLastArgType': '',
                                                   'kLong': '',
                                                   'kNoArg': '',
                                                   'kSelectionItem': '',
                                                   'kString': '',
                                                   'kTime': '',
                                                   'kUnsigned': '',
                                                   'lastArgType': '',
                                                   'long': '',
                                                   'noArg': '',
                                                   'selectionItem': '',
                                                   'string': '',
                                                   'time': '',
                                                   'unsigned': ''},
                                     'values': "Enum('MArgType', {'kInvalidArgType': 0, 'kNoArg': 1, 'kBoolean': 2, 'kLong': 3, 'kDouble': 4, 'kString': 5, 'kUnsigned': 6, 'kDistance': 7, 'kAngle': 8, 'kTime': 9, 'kSelectionItem': 10, 'kLastArgType': 11})"},
                        'MObjectFormat': {'valueDocs': {'invalidObjectFormat': '',
                                                        'kInvalidObjectFormat': '',
                                                        'kLastObjectFormat': '',
                                                        'kNone': '',
                                                        'kSelectionList': '',
                                                        'kStringObjects': '',
                                                        'lastObjectFormat': '',
                                                        'none': '',
                                                        'selectionList': '',
                                                        'stringObjects': ''},
                                          'values': "Enum('MObjectFormat', {'kInvalidObjectFormat': 0, 'kNone': 1, 'kStringObjects': 2, 'kSelectionList': 3, 'kLastObjectFormat': 4})"}},
              'invertibles': [('setMaxObjects', 'maxObjects'),
                              ('setMinObjects', 'minObjects')],
              'methods': {'addArg': [{'argInfo': {'arg': {'doc': 'the type of the argument to the command',
                                                          'type': ('MSyntax',
                                                                   'MArgType')}},
                                      'args': [('arg',
                                                ('MSyntax', 'MArgType'),
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSpecifies the type of one of the arguments to the command. This method can be called multiple times to specify multiple arguments to the command.',
                                      'inArgs': ['arg'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'arg': []},
                                      'types': {'arg': ('MSyntax',
                                                        'MArgType')}}],
                          'addFlag': [{'argInfo': {'argType1': {'doc': 'type of the argument required by the flag, if any ',
                                                                'type': ('MSyntax',
                                                                         'MArgType')},
                                                   'argType2': {'doc': 'another type of the argument required by the flag, if any ',
                                                                'type': ('MSyntax',
                                                                         'MArgType')},
                                                   'argType3': {'doc': 'another type of the argument required by the flag, if any ',
                                                                'type': ('MSyntax',
                                                                         'MArgType')},
                                                   'argType4': {'doc': 'another type of the argument required by the flag, if any ',
                                                                'type': ('MSyntax',
                                                                         'MArgType')},
                                                   'argType5': {'doc': 'another type of the argument required by the flag, if any ',
                                                                'type': ('MSyntax',
                                                                         'MArgType')},
                                                   'argType6': {'doc': 'another type of the argument required by the flag, if any',
                                                                'type': ('MSyntax',
                                                                         'MArgType')},
                                                   'longName': {'doc': 'the string representing the int (> 3 character) version of the flag ',
                                                                'type': 'char'},
                                                   'shortName': {'doc': 'the string representing the short (< 4 character) version of the flag ',
                                                                 'type': 'char'}},
                                       'args': [('shortName',
                                                 'char',
                                                 'in'),
                                                ('longName',
                                                 'char',
                                                 'in'),
                                                ('argType1',
                                                 ('MSyntax',
                                                  'MArgType'),
                                                 'in'),
                                                ('argType2',
                                                 ('MSyntax',
                                                  'MArgType'),
                                                 'in'),
                                                ('argType3',
                                                 ('MSyntax',
                                                  'MArgType'),
                                                 'in'),
                                                ('argType4',
                                                 ('MSyntax',
                                                  'MArgType'),
                                                 'in'),
                                                ('argType5',
                                                 ('MSyntax',
                                                  'MArgType'),
                                                 'in'),
                                                ('argType6',
                                                 ('MSyntax',
                                                  'MArgType'),
                                                 'in')],
                                       'defaults': {'argType1': ('MSyntax',
                                                                 'MArgType',
                                                                 'kNoArg'),
                                                    'argType2': ('MSyntax',
                                                                 'MArgType',
                                                                 'kNoArg'),
                                                    'argType3': ('MSyntax',
                                                                 'MArgType',
                                                                 'kNoArg'),
                                                    'argType4': ('MSyntax',
                                                                 'MArgType',
                                                                 'kNoArg'),
                                                    'argType5': ('MSyntax',
                                                                 'MArgType',
                                                                 'kNoArg'),
                                                    'argType6': ('MSyntax',
                                                                 'MArgType',
                                                                 'kNoArg')},
                                       'deprecated': False,
                                       'doc': '\r\nAdds a flag to the list of flags accepted for the given command. Also specifies any arguments required by the flag.',
                                       'inArgs': ['shortName',
                                                  'longName',
                                                  'argType1',
                                                  'argType2',
                                                  'argType3',
                                                  'argType4',
                                                  'argType5',
                                                  'argType6'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'argType1': [],
                                                          'argType2': [],
                                                          'argType3': [],
                                                          'argType4': [],
                                                          'argType5': [],
                                                          'argType6': [],
                                                          'longName': ['const',
                                                                       '*'],
                                                          'shortName': ['const',
                                                                        '*']},
                                       'types': {'argType1': ('MSyntax',
                                                              'MArgType'),
                                                 'argType2': ('MSyntax',
                                                              'MArgType'),
                                                 'argType3': ('MSyntax',
                                                              'MArgType'),
                                                 'argType4': ('MSyntax',
                                                              'MArgType'),
                                                 'argType5': ('MSyntax',
                                                              'MArgType'),
                                                 'argType6': ('MSyntax',
                                                              'MArgType'),
                                                 'longName': 'char',
                                                 'shortName': 'char'}}],
                          'canEdit': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns whether or not the command supports the edit flag ("-e").',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                          'canQuery': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns whether or not the command supports the query flag ("-q").',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'bool'},
                                        'returnType': 'bool',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'enableEdit': [{'argInfo': {'supportsEdit': {'doc': 'if true, the command supports the edit flag ',
                                                                       'type': 'bool'}},
                                          'args': [('supportsEdit',
                                                    'bool',
                                                    'in')],
                                          'defaults': {'supportsEdit': True},
                                          'deprecated': False,
                                          'doc': '\r\nSets whether or not the command supports the edit flag ("-e").',
                                          'inArgs': ['supportsEdit'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'supportsEdit': []},
                                          'types': {'supportsEdit': 'bool'}}],
                          'enableQuery': [{'argInfo': {'supportsQuery': {'doc': 'if true, the command supports the query flag ',
                                                                         'type': 'bool'}},
                                           'args': [('supportsQuery',
                                                     'bool',
                                                     'in')],
                                           'defaults': {'supportsQuery': True},
                                           'deprecated': False,
                                           'doc': '\r\nSets whether or not the command supports the query flag ("-q").',
                                           'inArgs': ['supportsQuery'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'supportsQuery': []},
                                           'types': {'supportsQuery': 'bool'}}],
                          'makeFlagMultiUse': [{'argInfo': {'flag': {'doc': 'the flag to be made multi-use',
                                                                     'type': 'char'}},
                                                'args': [('flag',
                                                          'char',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSpecifies that the given flag can be used by the command multiple times in on the same command line.',
                                                'inArgs': ['flag'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'flag': ['const',
                                                                            '*']},
                                                'types': {'flag': 'char'}}],
                          'makeFlagQueryWithFullArgs': [{'argInfo': {'flag': {'doc': 'the flag which should be set to use arguments during query ',
                                                                              'type': 'char'},
                                                                     'queryArgsAreOptional': {'doc': 'set to true if the flag arguments are optional',
                                                                                              'type': 'bool'}},
                                                         'args': [('flag',
                                                                   'char',
                                                                   'in'),
                                                                  ('queryArgsAreOptional',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSpecifies that the given flag will require all of its arguments in query mode. Usually flags do not take arguments in query mode, since you are getting values instead of setting them. However, sometimes it is necessary to take arguments on a flag to allow the user to provide information which will help specify the scope of a query.',
                                                         'inArgs': ['flag',
                                                                    'queryArgsAreOptional'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'flag': ['const',
                                                                                     '*'],
                                                                            'queryArgsAreOptional': []},
                                                         'types': {'flag': 'char',
                                                                   'queryArgsAreOptional': 'bool'}}],
                          'maxObjects': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the upper limit on the number of objects accepted by the command.',
                                          'inArgs': [],
                                          'inverse': ('setMaxObjects',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'minObjects': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nReturns the lower limit on the number of objects accepted by the command.',
                                          'inArgs': [],
                                          'inverse': ('setMinObjects',
                                                      False),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'setMaxObjects': [{'argInfo': {'maximumObjectCount': {'doc': 'the upper limit of the number of objects ',
                                                                                'type': 'uint'}},
                                             'args': [('maximumObjectCount',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSpecifies the upper limit on the number of objects accepted by the command.',
                                             'inArgs': ['maximumObjectCount'],
                                             'inverse': ('maxObjects',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'maximumObjectCount': ['unsigned']},
                                             'types': {'maximumObjectCount': 'uint'}}],
                          'setMinObjects': [{'argInfo': {'minimumObjectCount': {'doc': 'the lower limit of the number of objects ',
                                                                                'type': 'uint'}},
                                             'args': [('minimumObjectCount',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSpecifies the lower limit on the number of objects accepted by the command.',
                                             'inArgs': ['minimumObjectCount'],
                                             'inverse': ('minObjects',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'minimumObjectCount': ['unsigned']},
                                             'types': {'minimumObjectCount': 'uint'}}],
                          'setObjectType': [{'argInfo': {'minimumObjects': {'doc': 'the minimum number of objects required by the command',
                                                                            'type': 'uint'},
                                                         'objectFormat': {'doc': 'the form of the objects passed to the command ',
                                                                          'type': ('MSyntax',
                                                                                   'MObjectFormat')}},
                                             'args': [('objectFormat',
                                                       ('MSyntax',
                                                        'MObjectFormat'),
                                                       'in'),
                                                      ('minimumObjects',
                                                       'uint',
                                                       'in')],
                                             'defaults': {'minimumObjects': 0},
                                             'deprecated': False,
                                             'doc': '\r\nSpecifies the representation of the objects passed to the command as either MObjects or MStrings. Also specifies the minimum number of objects required by the command.',
                                             'inArgs': ['objectFormat',
                                                        'minimumObjects'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'minimumObjects': ['unsigned'],
                                                                'objectFormat': []},
                                             'types': {'minimumObjects': 'uint',
                                                       'objectFormat': ('MSyntax',
                                                                        'MObjectFormat')}},
                                            {'argInfo': {'maximumObjects': {'doc': 'the upper limit of the number of objects',
                                                                            'type': 'uint'},
                                                         'minimumObjects': {'doc': 'the lower limit of the number of objects ',
                                                                            'type': 'uint'},
                                                         'objectFormat': {'doc': 'the form of the objects passed to the command ',
                                                                          'type': ('MSyntax',
                                                                                   'MObjectFormat')}},
                                             'args': [('objectFormat',
                                                       ('MSyntax',
                                                        'MObjectFormat'),
                                                       'in'),
                                                      ('minimumObjects',
                                                       'uint',
                                                       'in'),
                                                      ('maximumObjects',
                                                       'uint',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSpecifies the representation of the objects passed to the command as either MObjects or MStrings. Also specifies the upper and lower limits of the number of objects accepted by the command.',
                                             'inArgs': ['objectFormat',
                                                        'minimumObjects',
                                                        'maximumObjects'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'maximumObjects': ['unsigned'],
                                                                'minimumObjects': ['unsigned'],
                                                                'objectFormat': []},
                                             'types': {'maximumObjects': 'uint',
                                                       'minimumObjects': 'uint',
                                                       'objectFormat': ('MSyntax',
                                                                        'MObjectFormat')}}],
                          'useSelectionAsDefault': [{'argInfo': {'useSelectionList': {'doc': 'if true, the command will use the current selection list as arguments if none are specified',
                                                                                      'type': 'bool'}},
                                                     'args': [('useSelectionList',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {'useSelectionList': False},
                                                     'deprecated': False,
                                                     'doc': '\r\nSpecifies that the command will use the current selection list as arguments to the command if the command requires  objects  and none are provided}.',
                                                     'inArgs': ['useSelectionList'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'useSelectionList': []},
                                                     'types': {'useSelectionList': 'bool'}}]},
              'pymelEnums': {'MArgType': "Enum('MArgType', [('invalidArgType', 0), ('kInvalidArgType', 0), ('noArg', 1), ('kNoArg', 1), ('boolean', 2), ('kBoolean', 2), ('long', 3), ('kLong', 3), ('double', 4), ('kDouble', 4), ('string', 5), ('kString', 5), ('unsigned', 6), ('kUnsigned', 6), ('distance', 7), ('kDistance', 7), ('angle', 8), ('kAngle', 8), ('time', 9), ('kTime', 9), ('selectionItem', 10), ('kSelectionItem', 10), ('lastArgType', 11), ('kLastArgType', 11)], multiKeys=True)",
                             'MObjectFormat': "Enum('MObjectFormat', [('invalidObjectFormat', 0), ('kInvalidObjectFormat', 0), ('none', 1), ('kNone', 1), ('stringObjects', 2), ('kStringObjects', 2), ('selectionList', 3), ('kSelectionList', 3), ('lastObjectFormat', 4), ('kLastObjectFormat', 4)], multiKeys=True)"},
              'pymelMethods': {'maxObjects': 'getMaxObjects',
                               'minObjects': 'getMinObjects'}},
  'MTesselationParams': {'enums': {'IsoparmType': {'valueDocs': {'kSpanEquiSpaced': '',
                                                                 'kSurface3DDistance': '',
                                                                 'kSurface3DEquiSpaced': '',
                                                                 'kSurfaceEquiSpaced': '',
                                                                 'spanEquiSpaced': '',
                                                                 'surface3DDistance': '',
                                                                 'surface3DEquiSpaced': '',
                                                                 'surfaceEquiSpaced': ''},
                                                   'values': "Enum('IsoparmType', {'kSurface3DDistance': 0, 'kSurface3DEquiSpaced': 1, 'kSurfaceEquiSpaced': 2, 'kSpanEquiSpaced': 3})"},
                                   'PolyType': {'valueDocs': {'kQuads': '',
                                                              'kTriangles': '',
                                                              'quads': '',
                                                              'triangles': ''},
                                                'values': "Enum('PolyType', {'kTriangles': 0, 'kQuads': 1})"},
                                   'SubdivisionType': {'valueDocs': {'kLastFlag': '',
                                                                     'kUseChordHeightRatio': '',
                                                                     'kUseEdgeSmooth': '',
                                                                     'kUseFractionalTolerance': '',
                                                                     'kUseMaxEdgeLength': '',
                                                                     'kUseMaxNumberPolys': '',
                                                                     'kUseMaxSubdivisionLevel': '',
                                                                     'kUseMaxUVRectangleSize': '',
                                                                     'kUseMinEdgeLength': '',
                                                                     'kUseMinScreenSize': '',
                                                                     'kUseRelativeTolerance': '',
                                                                     'kUseTriangleEdgeSwapping': '',
                                                                     'lastFlag': '',
                                                                     'useChordHeightRatio': '',
                                                                     'useEdgeSmooth': '',
                                                                     'useFractionalTolerance': '',
                                                                     'useMaxEdgeLength': '',
                                                                     'useMaxNumberPolys': '',
                                                                     'useMaxSubdivisionLevel': '',
                                                                     'useMaxUVRectangleSize': '',
                                                                     'useMinEdgeLength': '',
                                                                     'useMinScreenSize': '',
                                                                     'useRelativeTolerance': '',
                                                                     'useTriangleEdgeSwapping': ''},
                                                       'values': "Enum('SubdivisionType', {'kUseFractionalTolerance': 0, 'kUseChordHeightRatio': 1, 'kUseMinEdgeLength': 2, 'kUseMaxEdgeLength': 3, 'kUseMaxNumberPolys': 4, 'kUseMaxSubdivisionLevel': 5, 'kUseMinScreenSize': 6, 'kUseMaxUVRectangleSize': 7, 'kUseTriangleEdgeSwapping': 8, 'kUseRelativeTolerance': 9, 'kUseEdgeSmooth': 10, 'kLastFlag': 11})"},
                                   'TessFormat': {'valueDocs': {'generalFormat': '',
                                                                'kGeneralFormat': '',
                                                                'kStandardFitFormat': '',
                                                                'kTriangleCountFormat': '',
                                                                'standardFitFormat': '',
                                                                'triangleCountFormat': ''},
                                                  'values': "Enum('TessFormat', {'kTriangleCountFormat': 0, 'kStandardFitFormat': 1, 'kGeneralFormat': 2})"}},
                         'methods': {'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'set3DDelta': [{'argInfo': {'delta': {'doc': 'the fractional spacing factor, a value between 0 and 1 ',
                                                                           'type': 'double'}},
                                                     'args': [('delta',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSets the fraction of the box diagonal to be used as 3-d spacing for u- and v-isoparams on face/surface to make up the initial grid for the mesh. This is used when the tesselation format is  kStandardFitFormat .',
                                                     'inArgs': ['delta'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'delta': []},
                                                     'types': {'delta': 'double'}}],
                                     'setBoundingBoxDiagonal': [{'argInfo': {'distance': {'doc': 'the diagonal bounding box distance ',
                                                                                          'type': 'double'}},
                                                                 'args': [('distance',
                                                                           'double',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the diagonal distance of the bounding box of the surface.',
                                                                 'inArgs': ['distance'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'distance': []},
                                                                 'types': {'distance': 'double'}}],
                                     'setChordHeightRatio': [{'argInfo': {'value': {'doc': 'the new chord height ratio value to be set ',
                                                                                    'type': 'double'}},
                                                              'args': [('value',
                                                                        'double',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the chord height ratio. This value is used when the subdivision criteria  kUseChordHeightRatio  has been set.',
                                                              'inArgs': ['value'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'value': []},
                                                              'types': {'value': 'double'}}],
                                     'setEdgeSmoothFactor': [{'argInfo': {'smoothness': {'doc': 'a factor from 0(not smooth) to 1(very smooth) indicating nurbs-edge smoothness ',
                                                                                         'type': 'double'}},
                                                              'args': [('smoothness',
                                                                        'double',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the edge smoothness factor used for the Edge Smooth secondary tesselation criteria.',
                                                              'inArgs': ['smoothness'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'smoothness': []},
                                                              'types': {'smoothness': 'double'}}],
                                     'setFitTolerance': [{'argInfo': {'value': {'doc': 'the new absolute fit tolerance value to be set ',
                                                                                'type': 'double'}},
                                                          'args': [('value',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the absolute fit tolerance. This value is used when the subdivision criteria  kUseFractionalTolerance  has been set.',
                                                          'inArgs': ['value'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'value': []},
                                                          'types': {'value': 'double'}}],
                                     'setFormatType': [{'argInfo': {'format': {'doc': 'the subdivision format. See the class description for list of format types and descriptions. ',
                                                                               'type': ('MTesselationParams',
                                                                                        'TessFormat')}},
                                                        'args': [('format',
                                                                  ('MTesselationParams',
                                                                   'TessFormat'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSets the tesselation format. The tesselation format is used in the secondary tesselation stage to specify the subdivision criteria used in refining the initial mesh.',
                                                        'inArgs': ['format'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'format': []},
                                                        'types': {'format': ('MTesselationParams',
                                                                             'TessFormat')}}],
                                     'setMaxEdgeLength': [{'argInfo': {'value': {'doc': 'the new maximum edge length value to be set ',
                                                                                 'type': 'double'}},
                                                           'args': [('value',
                                                                     'double',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the maximum edge length. This value is used when the subdivision criteria  kUseMaxEdgeLength  has been set.',
                                                           'inArgs': ['value'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'value': []},
                                                           'types': {'value': 'double'}}],
                                     'setMaxNumberPolys': [{'argInfo': {'value': {'doc': 'the new maximum number of polygons value to be set ',
                                                                                  'type': 'int'}},
                                                            'args': [('value',
                                                                      'int',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nSets the maximum number of polygons. This value is used when the subdivision criteria  kUseMaxNumberPolys  has been set.',
                                                            'inArgs': ['value'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'value': []},
                                                            'types': {'value': 'int'}}],
                                     'setMaxSubdivisionLevel': [{'argInfo': {'value': {'doc': 'the new maximum subdivision level value to be set ',
                                                                                       'type': 'double'}},
                                                                 'args': [('value',
                                                                           'double',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the maximum subdivision level. This value is used when the subdivision criteria  kUseMaxSubdivisionLevel  has been set.',
                                                                 'inArgs': ['value'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'value': []},
                                                                 'types': {'value': 'double'}}],
                                     'setMaxUVRectangleSize': [{'argInfo': {'u': {'doc': 'horizontal screen space size ',
                                                                                  'type': 'double'},
                                                                            'v': {'doc': 'vertical screen space size ',
                                                                                  'type': 'double'}},
                                                                'args': [('u',
                                                                          'double',
                                                                          'in'),
                                                                         ('v',
                                                                          'double',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nSets the maximum polygon size in uv-space for secondary tesselation. Polygons will be greater than the specified size.',
                                                                'inArgs': ['u',
                                                                           'v'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {'u': [],
                                                                                   'v': []},
                                                                'types': {'u': 'double',
                                                                          'v': 'double'}}],
                                     'setMinEdgeLength': [{'argInfo': {'value': {'doc': 'the new minimum edge length value to be set ',
                                                                                 'type': 'double'}},
                                                           'args': [('value',
                                                                     'double',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the minimum edge length. This value is used when the subdivision criteria  kUseMinEdgeLength  has been set.',
                                                           'inArgs': ['value'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'value': []},
                                                           'types': {'value': 'double'}}],
                                     'setMinScreenSize': [{'argInfo': {'x': {'doc': 'the width value to compare against ',
                                                                             'type': 'double'},
                                                                       'y': {'doc': 'the height value to compare against ',
                                                                             'type': 'double'}},
                                                           'args': [('x',
                                                                     'double',
                                                                     'in'),
                                                                    ('y',
                                                                     'double',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nIf polygons are smaller than the specified screen size then the subdivision will not proceed. These values are used when the subdivision criteria  kUseMinScreenSize  has been set.',
                                                           'inArgs': ['x',
                                                                      'y'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'x': [],
                                                                              'y': []},
                                                           'types': {'x': 'double',
                                                                     'y': 'double'}}],
                                     'setOutputType': [{'argInfo': {'outputType': {'doc': 'the type of polygon in the tesselated object ',
                                                                                   'type': ('MTesselationParams',
                                                                                            'PolyType')}},
                                                        'args': [('outputType',
                                                                  ('MTesselationParams',
                                                                   'PolyType'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\nSpecifies the type of polygons in the tesselated object.',
                                                        'inArgs': ['outputType'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'outputType': []},
                                                        'types': {'outputType': ('MTesselationParams',
                                                                                 'PolyType')}}],
                                     'setRelativeFitTolerance': [{'argInfo': {'value': {'doc': 'the new relative fit tolerance value to be set ',
                                                                                        'type': 'double'}},
                                                                  'args': [('value',
                                                                            'double',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\nSets the relative fit tolerance. This value is used when the subdivision criteria  kUseRelativeTolerance  has been set.',
                                                                  'inArgs': ['value'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'value': []},
                                                                  'types': {'value': 'double'}}],
                                     'setStdChordHeightRatio': [{'argInfo': {'value': {'doc': 'the chord height ration value to be set ',
                                                                                       'type': 'double'}},
                                                                 'args': [('value',
                                                                           'double',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\nSets the chord height ratio which is used when the tesselation format is  kStandardFitFormat .',
                                                                 'inArgs': ['value'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'value': []},
                                                                 'types': {'value': 'double'}}],
                                     'setStdFractionalTolerance': [{'argInfo': {'value': {'doc': 'the fractional tolerance value to be set ',
                                                                                          'type': 'double'}},
                                                                    'args': [('value',
                                                                              'double',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\nSets the fractional tolerance which is used when the tesselation format is  kStandardFitFormat .',
                                                                    'inArgs': ['value'],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'value': []},
                                                                    'types': {'value': 'double'}}],
                                     'setStdMinEdgeLength': [{'argInfo': {'value': {'doc': 'the minimum edge length to be set ',
                                                                                    'type': 'double'}},
                                                              'args': [('value',
                                                                        'double',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\nSets the minimum edge length which is used when the tesselation format is  kStandardFitFormat .',
                                                              'inArgs': ['value'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'value': []},
                                                              'types': {'value': 'double'}}],
                                     'setSubdivisionFlag': [{'argInfo': {'subType': {'doc': 'the subdivision type to be specified ',
                                                                                     'type': ('MTesselationParams',
                                                                                              'SubdivisionType')},
                                                                         'use': {'doc': 'specifies whether to use subType subdivision ',
                                                                                 'type': 'bool'}},
                                                             'args': [('subType',
                                                                       ('MTesselationParams',
                                                                        'SubdivisionType'),
                                                                       'in'),
                                                                      ('use',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\nSets the types of subdivision used when the tesselation format is general. This method allows you to set the types of subdivision to be performed after the initial mesh is created. The  use  flag specifies whether to use the given subdivision type in the secondary tesselation.',
                                                             'inArgs': ['subType',
                                                                        'use'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'subType': [],
                                                                                'use': []},
                                                             'types': {'subType': ('MTesselationParams',
                                                                                   'SubdivisionType'),
                                                                       'use': 'bool'}}],
                                     'setTriangleCount': [{'argInfo': {'count': {'doc': 'The approximate number of triangular polygons in the tesselated object ',
                                                                                 'type': 'int'}},
                                                           'args': [('count',
                                                                     'int',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nSets the approximate number of triangles for the tesselated object when the format is  kTriangleCountFormat .',
                                                           'inArgs': ['count'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'count': []},
                                                           'types': {'count': 'int'}}],
                                     'setUDistanceFraction': [{'argInfo': {'value': {'doc': 'the bounding box distance fraction to set ',
                                                                                     'type': 'double'}},
                                                               'args': [('value',
                                                                         'double',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nSets the fraction of the 3D surface bounding box diagonal for the kSurface3DDistance isoparm type. The value is 0.0 for other types.',
                                                               'inArgs': ['value'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'value': []},
                                                               'types': {'value': 'double'}}],
                                     'setUIsoparmType': [{'argInfo': {'uValue': {'doc': 'the u-isoparm type ',
                                                                                 'type': ('MTesselationParams',
                                                                                          'IsoparmType')}},
                                                          'args': [('uValue',
                                                                    ('MTesselationParams',
                                                                     'IsoparmType'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the u-isoparm type to be used in the initial tesselation.',
                                                          'inArgs': ['uValue'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'uValue': []},
                                                          'types': {'uValue': ('MTesselationParams',
                                                                               'IsoparmType')}}],
                                     'setUNumber': [{'argInfo': {'count': {'doc': 'the number of u isoparms ',
                                                                           'type': 'int'}},
                                                     'args': [('count',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nThis is the number of u isoparms used in the initial tesselation. This value is only used for kSurface3DEquiSpaced, kSurfaceEquiSpaced, and kSpanEquiSpaced isoparm types.',
                                                     'inArgs': ['count'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'count': []},
                                                     'types': {'count': 'int'}}],
                                     'setVDistanceFraction': [{'argInfo': {'value': {'doc': 'the bounding box distance fraction to set ',
                                                                                     'type': 'double'}},
                                                               'args': [('value',
                                                                         'double',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\nSets the fraction of the 3D surface bounding box diagonal for the kSurface3DDistance isoparm type. The value is 0.0 for other types.',
                                                               'inArgs': ['value'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'value': []},
                                                               'types': {'value': 'double'}}],
                                     'setVIsoparmType': [{'argInfo': {'vValue': {'doc': 'the v-isoparm type ',
                                                                                 'type': ('MTesselationParams',
                                                                                          'IsoparmType')}},
                                                          'args': [('vValue',
                                                                    ('MTesselationParams',
                                                                     'IsoparmType'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\nSets the v-isoparm type to be used in the initial tesselation.',
                                                          'inArgs': ['vValue'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'vValue': []},
                                                          'types': {'vValue': ('MTesselationParams',
                                                                               'IsoparmType')}}],
                                     'setVNumber': [{'argInfo': {'count': {'doc': 'the number of v isoparms ',
                                                                           'type': 'int'}},
                                                     'args': [('count',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nThis is the number of v isoparms used in the initial tesselation. This value is only used for kSurface3DEquiSpaced, kSurfaceEquiSpaced, and kSpanEquiSpaced isoparm types.',
                                                     'inArgs': ['count'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'count': []},
                                                     'types': {'count': 'int'}}],
                                     'setWorldspaceToScreenTransform': [{'argInfo': {'value': {'doc': 'The world-space transformation matrix ',
                                                                                               'type': 'MMatrix'}},
                                                                         'args': [('value',
                                                                                   'MMatrix',
                                                                                   'in')],
                                                                         'defaults': {},
                                                                         'deprecated': False,
                                                                         'doc': '\nThe transformation matrix used in the minimum screen size test for subdivision. This value is used when the subdivision criteria  kUseMinScreenSize  has been set.',
                                                                         'inArgs': ['value'],
                                                                         'outArgs': [],
                                                                         'returnInfo': {'doc': '',
                                                                                        'qualifiers': [],
                                                                                        'type': None},
                                                                         'returnType': None,
                                                                         'static': False,
                                                                         'typeQualifiers': {'value': ['&']},
                                                                         'types': {'value': 'MMatrix'}}]},
                         'pymelEnums': {'IsoparmType': "Enum('IsoparmType', [('surface3DDistance', 0), ('kSurface3DDistance', 0), ('surface3DEquiSpaced', 1), ('kSurface3DEquiSpaced', 1), ('surfaceEquiSpaced', 2), ('kSurfaceEquiSpaced', 2), ('spanEquiSpaced', 3), ('kSpanEquiSpaced', 3)], multiKeys=True)",
                                        'PolyType': "Enum('PolyType', [('triangles', 0), ('kTriangles', 0), ('quads', 1), ('kQuads', 1)], multiKeys=True)",
                                        'SubdivisionType': "Enum('SubdivisionType', [('useFractionalTolerance', 0), ('kUseFractionalTolerance', 0), ('useChordHeightRatio', 1), ('kUseChordHeightRatio', 1), ('useMinEdgeLength', 2), ('kUseMinEdgeLength', 2), ('useMaxEdgeLength', 3), ('kUseMaxEdgeLength', 3), ('useMaxNumberPolys', 4), ('kUseMaxNumberPolys', 4), ('useMaxSubdivisionLevel', 5), ('kUseMaxSubdivisionLevel', 5), ('useMinScreenSize', 6), ('kUseMinScreenSize', 6), ('useMaxUVRectangleSize', 7), ('kUseMaxUVRectangleSize', 7), ('useTriangleEdgeSwapping', 8), ('kUseTriangleEdgeSwapping', 8), ('useRelativeTolerance', 9), ('kUseRelativeTolerance', 9), ('useEdgeSmooth', 10), ('kUseEdgeSmooth', 10), ('lastFlag', 11), ('kLastFlag', 11)], multiKeys=True)",
                                        'TessFormat': "Enum('TessFormat', [('triangleCountFormat', 0), ('kTriangleCountFormat', 0), ('standardFitFormat', 1), ('kStandardFitFormat', 1), ('generalFormat', 2), ('kGeneralFormat', 2)], multiKeys=True)"}},
  'MTextureEditorDrawInfo': {'enums': {'DrawingFunction': {'valueDocs': {'UVForSelect': 'Draw uvs for selection.',
                                                                         'edgeForSelect': 'Draw edges for selection.',
                                                                         'everything': 'Draw vertices, uvs, faces, and edges.',
                                                                         'facetForSelect': 'Draw faces for selection.',
                                                                         'functionFirst': 'Lowest possible enum value.',
                                                                         'functionLast': 'Highest possible enum value.',
                                                                         'kDrawEdgeForSelect': 'Draw edges for selection.',
                                                                         'kDrawEverything': 'Draw vertices, uvs, faces, and edges.',
                                                                         'kDrawFacetForSelect': 'Draw faces for selection.',
                                                                         'kDrawFunctionFirst': 'Lowest possible enum value.',
                                                                         'kDrawFunctionLast': 'Highest possible enum value.',
                                                                         'kDrawUVForSelect': 'Draw uvs for selection.',
                                                                         'kDrawVertexForSelect': 'Draw vertices for selection.',
                                                                         'kDrawWireframe': 'Draw wireframe only (default).',
                                                                         'vertexForSelect': 'Draw vertices for selection.',
                                                                         'wireframe': 'Draw wireframe only (default).'},
                                                           'values': "Enum('DrawingFunction', [('kDrawWireframe', 1), ('kDrawFunctionFirst', 1), ('kDrawEverything', 2), ('kDrawVertexForSelect', 3), ('kDrawEdgeForSelect', 4), ('kDrawFacetForSelect', 5), ('kDrawFunctionLast', 6), ('kDrawUVForSelect', 6)], multiKeys=True)"}},
                             'invertibles': [('setDrawingFunction',
                                              'drawingFunction')],
                             'methods': {'className': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the name of this class.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'char'},
                                                        'returnType': 'char',
                                                        'static': True,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                         'drawingFunction': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nIndicates the current drawing state for a drawUV method call.',
                                                              'inArgs': [],
                                                              'inverse': ('setDrawingFunction',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': ('MTextureEditorDrawInfo',
                                                                                      'DrawingFunction')},
                                                              'returnType': ('MTextureEditorDrawInfo',
                                                                             'DrawingFunction'),
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                         'setDrawingFunction': [{'argInfo': {'func': {'doc': 'drawing function. ',
                                                                                      'type': ('MTextureEditorDrawInfo',
                                                                                               'DrawingFunction')}},
                                                                 'args': [('func',
                                                                           ('MTextureEditorDrawInfo',
                                                                            'DrawingFunction'),
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nSets the current drawing state. Currently the API user is unable to set these values. All drawing state values are determined internally and passed onto the API programmer.',
                                                                 'inArgs': ['func'],
                                                                 'inverse': ('drawingFunction',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'func': []},
                                                                 'types': {'func': ('MTextureEditorDrawInfo',
                                                                                    'DrawingFunction')}}]},
                             'pymelEnums': {'DrawingFunction': "Enum('DrawingFunction', [('wireframe', 1), ('functionFirst', 1), ('kDrawFunctionFirst', 1), ('kDrawWireframe', 1), ('everything', 2), ('kDrawEverything', 2), ('vertexForSelect', 3), ('kDrawVertexForSelect', 3), ('edgeForSelect', 4), ('kDrawEdgeForSelect', 4), ('facetForSelect', 5), ('kDrawFacetForSelect', 5), ('functionLast', 6), ('UVForSelect', 6), ('kDrawFunctionLast', 6), ('kDrawUVForSelect', 6)], multiKeys=True)"},
                             'pymelMethods': {'drawingFunction': 'getDrawingFunction'}},
  'MTime': {'enums': {'Unit': {'valueDocs': {'NTSCField': '',
                                             'NTSCFrame': '',
                                             'PALField': '',
                                             'PALFrame': '',
                                             'film': '',
                                             'games': '',
                                             'hours': '3600 seconds',
                                             'invalid': 'Invalid value.',
                                             'k100FPS': '100 frames per second',
                                             'k10FPS': '10 frames per second',
                                             'k1200FPS': '1200 frames per second',
                                             'k120FPS': '120 frames per second',
                                             'k125FPS': '125 frames per second',
                                             'k12FPS': '12 frames per second',
                                             'k1500FPS': '1500 frames per second',
                                             'k150FPS': '150 frames per second',
                                             'k15FPS': '15 frames per second',
                                             'k16FPS': '16 frames per second',
                                             'k2000FPS': '2000 frames per second',
                                             'k200FPS': '200 frames per second',
                                             'k20FPS': '20 frames per second',
                                             'k23_976FPS': '23.976 frames per second',
                                             'k240FPS': '240 frames per second',
                                             'k24FPS': '24 frames per second',
                                             'k250FPS': '250 frames per second',
                                             'k25FPS': '25 frames per second',
                                             'k29_97DF': '29.97 frames per second with DF TimeCode representation',
                                             'k29_97FPS': '29.97 frames per second',
                                             'k2FPS': '2 frames per second',
                                             'k3000FPS': '3000 frames per second',
                                             'k300FPS': '300 frames per second',
                                             'k30FPS': '30 frames per second',
                                             'k375FPS': '375 frames per second',
                                             'k3FPS': '3 frames per second',
                                             'k400FPS': '400 frames per second',
                                             'k40FPS': '40 frames per second',
                                             'k44100FPS': '44100 frames per second',
                                             'k47_952FPS': '47.952 frames per second',
                                             'k48000FPS': '48000 frames per second',
                                             'k48FPS': 'twice the speed of film (48 frames per second)',
                                             'k4FPS': '4 frames per second',
                                             'k500FPS': '500 frames per second',
                                             'k50FPS': 'twice the speed of PAL (50 frames per second)',
                                             'k59_94FPS': '59.94 frames per second',
                                             'k5FPS': '5 frames per second',
                                             'k6000FPS': '6000 frames per second',
                                             'k600FPS': '600 frames per second',
                                             'k60FPS': 'twice the speed of NTSC (60 frames per second)',
                                             'k6FPS': '6 frames per second',
                                             'k750FPS': '750 frames per second',
                                             'k75FPS': '75 frames per second',
                                             'k80FPS': '80 frames per second',
                                             'k8FPS': '8 frames per second',
                                             'kFilm': '',
                                             'kGames': '',
                                             'kHours': '3600 seconds',
                                             'kInvalid': 'Invalid value.',
                                             'kLast': 'Last value, used for counting.',
                                             'kMilliseconds': '1/1000 of a second',
                                             'kMinutes': '60 seconds',
                                             'kNTSCField': '',
                                             'kNTSCFrame': '',
                                             'kPALField': '',
                                             'kPALFrame': '',
                                             'kSeconds': '1 second',
                                             'kShowScan': '',
                                             'kUserDef': 'user defined units (not implemented yet)',
                                             'last': 'Last value, used for counting.',
                                             'milliseconds': '1/1000 of a second',
                                             'minutes': '60 seconds',
                                             'seconds': '1 second',
                                             'showScan': '',
                                             'userDef': 'user defined units (not implemented yet)'},
                               'values': "Enum('Unit', [('kInvalid', 0), ('kHours', 1), ('kMinutes', 2), ('kSeconds', 3), ('kMilliseconds', 4), ('k15FPS', 5), ('kGames', 5), ('kFilm', 6), ('k24FPS', 6), ('k25FPS', 7), ('kPALFrame', 7), ('kNTSCFrame', 8), ('k30FPS', 8), ('k48FPS', 9), ('kShowScan', 9), ('k50FPS', 10), ('kPALField', 10), ('kNTSCField', 11), ('k60FPS', 11), ('k2FPS', 12), ('k3FPS', 13), ('k4FPS', 14), ('k5FPS', 15), ('k6FPS', 16), ('k8FPS', 17), ('k10FPS', 18), ('k12FPS', 19), ('k16FPS', 20), ('k20FPS', 21), ('k40FPS', 22), ('k75FPS', 23), ('k80FPS', 24), ('k100FPS', 25), ('k120FPS', 26), ('k125FPS', 27), ('k150FPS', 28), ('k200FPS', 29), ('k240FPS', 30), ('k250FPS', 31), ('k300FPS', 32), ('k375FPS', 33), ('k400FPS', 34), ('k500FPS', 35), ('k600FPS', 36), ('k750FPS', 37), ('k1200FPS', 38), ('k1500FPS', 39), ('k2000FPS', 40), ('k3000FPS', 41), ('k6000FPS', 42), ('k23_976FPS', 43), ('k29_97FPS', 44), ('k29_97DF', 45), ('k47_952FPS', 46), ('k59_94FPS', 47), ('k44100FPS', 48), ('k48000FPS', 49), ('kUserDef', 50), ('kLast', 51)], multiKeys=True)"}},
            'invertibles': [('setValue', 'value'), ('setUnit', 'unit')],
            'methods': {'__add__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                         'type': 'MTime'}},
                                     'args': [('rhs', 'MTime', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nAddition with another  MTime .',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'rhs': ['const',
                                                                '&']},
                                     'types': {'rhs': 'MTime'}},
                                    {'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                         'type': 'double'}},
                                     'args': [('rhs', 'double', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nAddition with a double.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'rhs': []},
                                     'types': {'rhs': 'double'}}],
                        '__div__': [{'argInfo': {'rhs': {'doc': 'the scalar to divide by. ',
                                                         'type': 'double'}},
                                     'args': [('rhs', 'double', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nDivision by a scalar operator. Divide the instance to the left of the / operator by the given double, and assign the result to a new  MTime  instance.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'rhs': []},
                                     'types': {'rhs': 'double'}}],
                        '__eq__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                        'type': 'MTime'}},
                                    'args': [('rhs', 'MTime', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nEquality operator.',
                                    'inArgs': ['rhs'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'rhs': ['const',
                                                               '&']},
                                    'types': {'rhs': 'MTime'}}],
                        '__iadd__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                          'type': 'MTime'}},
                                      'args': [('rhs', 'MTime', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nIn-place addition with another  MTime .',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {'rhs': ['const',
                                                                 '&']},
                                      'types': {'rhs': 'MTime'}},
                                     {'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                          'type': 'double'}},
                                      'args': [('rhs', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nIn-place addition with a double.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {'rhs': []},
                                      'types': {'rhs': 'double'}}],
                        '__idiv__': [{'argInfo': {'rhs': {'doc': 'the scalar to multiply by. ',
                                                          'type': 'double'}},
                                      'args': [('rhs', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nIn place division by a scalar operator. Divide the current instance by the given double.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {'rhs': []},
                                      'types': {'rhs': 'double'}}],
                        '__imul__': [{'argInfo': {'rhs': {'doc': 'the scalar to multiply by. ',
                                                          'type': 'double'}},
                                      'args': [('rhs', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nIn place multiplication by a scalar operator. Multiply the current instance by the given double.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {'rhs': []},
                                      'types': {'rhs': 'double'}}],
                        '__isub__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                          'type': 'MTime'}},
                                      'args': [('rhs', 'MTime', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nIn-place subtraction of another  MTime .',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {'rhs': ['const',
                                                                 '&']},
                                      'types': {'rhs': 'MTime'}},
                                     {'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                          'type': 'double'}},
                                      'args': [('rhs', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nIn-place Subtraction of a double.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {'rhs': []},
                                      'types': {'rhs': 'double'}}],
                        '__mul__': [{'argInfo': {'rhs': {'doc': 'the scalar to multiply by. ',
                                                         'type': 'double'}},
                                     'args': [('rhs', 'double', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nMultiplication by a scalar operator. Multiply the instance to the left of the * operator by the given double, and assign the result to a new  MTime  instance.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'rhs': []},
                                     'types': {'rhs': 'double'}}],
                        '__ne__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                        'type': 'MTime'}},
                                    'args': [('rhs', 'MTime', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nInEquality operator.',
                                    'inArgs': ['rhs'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'rhs': ['const',
                                                               '&']},
                                    'types': {'rhs': 'MTime'}}],
                        '__sub__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                         'type': 'MTime'}},
                                     'args': [('rhs', 'MTime', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nSubtraction of another  MTime .',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'rhs': ['const',
                                                                '&']},
                                     'types': {'rhs': 'MTime'}},
                                    {'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                         'type': 'double'}},
                                     'args': [('rhs', 'double', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nSubtraction of a double.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'rhs': []},
                                     'types': {'rhs': 'double'}}],
                        'as': [{'argInfo': {'newUnit': {'doc': 'an element of the MTime::Unit enum',
                                                        'type': ('MTime',
                                                                 'Unit')}},
                                'args': [('newUnit',
                                          ('MTime', 'Unit'),
                                          'in')],
                                'defaults': {},
                                'deprecated': False,
                                'doc': '\r\nReturns the current time value in the given units. This does not affect the current units for the instance.',
                                'inArgs': ['newUnit'],
                                'outArgs': [],
                                'returnInfo': {'doc': 'The current time value in the given units ',
                                               'qualifiers': [],
                                               'type': 'double'},
                                'returnType': 'double',
                                'static': False,
                                'typeQualifiers': {'newUnit': []},
                                'types': {'newUnit': ('MTime', 'Unit')}}],
                        'asUnits': [{'argInfo': {'newUnit': {'doc': 'an element of the MTime::Unit enum',
                                                             'type': ('MTime',
                                                                      'Unit')}},
                                     'args': [('newUnit',
                                               ('MTime', 'Unit'),
                                               'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nReturns the current time value in the given units. This does not affect the current units for the instance.',
                                     'inArgs': ['newUnit'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'The current time value in the given units ',
                                                    'qualifiers': [],
                                                    'type': 'double'},
                                     'returnType': 'double',
                                     'static': False,
                                     'typeQualifiers': {'newUnit': []},
                                     'types': {'newUnit': ('MTime',
                                                           'Unit')}}],
                        'className': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nReturns the name of this class.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': ['*'],
                                                      'type': 'char'},
                                       'returnType': 'char',
                                       'static': True,
                                       'typeQualifiers': {},
                                       'types': {}}],
                        'setUIUnit': [{'argInfo': {'newUnit': {'doc': 'an element of the MTime::Unit enum',
                                                               'type': ('MTime',
                                                                        'Unit')}},
                                       'args': [('newUnit',
                                                 ('MTime', 'Unit'),
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': "\r\nSet the unit system to be used by the user in the UI. After the successful completion of this method, Maya's timeslider will be displaying  frames  in the specified units.",
                                       'inArgs': ['newUnit'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': True,
                                       'typeQualifiers': {'newUnit': []},
                                       'types': {'newUnit': ('MTime',
                                                             'Unit')}}],
                        'setUnit': [{'argInfo': {'newUnit': {'doc': 'an element of the MTime::Unit enum',
                                                             'type': ('MTime',
                                                                      'Unit')}},
                                     'args': [('newUnit',
                                               ('MTime', 'Unit'),
                                               'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nSet the current units in effect on this  MTime  instance. Note that this method only changes the current units in the instance, it does not affect the value. So, calls to the value method before and after a call to setUnit will return the same number, however, the interpretation of that number will be different due to the change in unit systems.',
                                     'inArgs': ['newUnit'],
                                     'inverse': ('unit', True),
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {'newUnit': []},
                                     'types': {'newUnit': ('MTime',
                                                           'Unit')}}],
                        'setValue': [{'argInfo': {'newValue': {'doc': 'The new time value.',
                                                               'type': 'double'}},
                                      'args': [('newValue',
                                                'double',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSet the current time value in the current units for this instance.',
                                      'inArgs': ['newValue'],
                                      'inverse': ('value', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'newValue': []},
                                      'types': {'newValue': 'double'}}],
                        'ticksPerSecond': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the number of ticks per second, the smallest unit of time available.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': ('MTime',
                                                                    'MTick')},
                                            'returnType': ('MTime',
                                                           'MTick'),
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                        'uiUnit': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': "\r\nReturns the Working Units (or UI units) chosen in the settings of the prefs window. Maya's timeslider displays  frames  in these units.",
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'An element of the MTime::Unit enum ',
                                                   'qualifiers': [],
                                                   'type': ('MTime',
                                                            'Unit')},
                                    'returnType': ('MTime', 'Unit'),
                                    'static': True,
                                    'typeQualifiers': {},
                                    'types': {}}],
                        'unit': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nReturns the current units in effect for this instance.',
                                  'inArgs': [],
                                  'inverse': ('setUnit', False),
                                  'outArgs': [],
                                  'returnInfo': {'doc': '',
                                                 'qualifiers': [],
                                                 'type': ('MTime',
                                                          'Unit')},
                                  'returnType': ('MTime', 'Unit'),
                                  'static': False,
                                  'typeQualifiers': {},
                                  'types': {}}],
                        'value': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nReturns the current time value in the units that are currently in effect for this instance.',
                                   'inArgs': [],
                                   'inverse': ('setValue', False),
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'The current time value ',
                                                  'qualifiers': [],
                                                  'type': 'double'},
                                   'returnType': 'double',
                                   'static': False,
                                   'typeQualifiers': {},
                                   'types': {}}]},
            'pymelEnums': {'Unit': "Enum('Unit', [('invalid', 0), ('kInvalid', 0), ('hours', 1), ('kHours', 1), ('minutes', 2), ('kMinutes', 2), ('seconds', 3), ('kSeconds', 3), ('milliseconds', 4), ('kMilliseconds', 4), ('k15FPS', 5), ('games', 5), ('kGames', 5), ('film', 6), ('k24FPS', 6), ('kFilm', 6), ('k25FPS', 7), ('PALFrame', 7), ('kPALFrame', 7), ('NTSCFrame', 8), ('k30FPS', 8), ('kNTSCFrame', 8), ('k48FPS', 9), ('kShowScan', 9), ('showScan', 9), ('k50FPS', 10), ('PALField', 10), ('kPALField', 10), ('NTSCField', 11), ('k60FPS', 11), ('kNTSCField', 11), ('k2FPS', 12), ('k3FPS', 13), ('k4FPS', 14), ('k5FPS', 15), ('k6FPS', 16), ('k8FPS', 17), ('k10FPS', 18), ('k12FPS', 19), ('k16FPS', 20), ('k20FPS', 21), ('k40FPS', 22), ('k75FPS', 23), ('k80FPS', 24), ('k100FPS', 25), ('k120FPS', 26), ('k125FPS', 27), ('k150FPS', 28), ('k200FPS', 29), ('k240FPS', 30), ('k250FPS', 31), ('k300FPS', 32), ('k375FPS', 33), ('k400FPS', 34), ('k500FPS', 35), ('k600FPS', 36), ('k750FPS', 37), ('k1200FPS', 38), ('k1500FPS', 39), ('k2000FPS', 40), ('k3000FPS', 41), ('k6000FPS', 42), ('k23_976FPS', 43), ('k29_97FPS', 44), ('k29_97DF', 45), ('k47_952FPS', 46), ('k59_94FPS', 47), ('k44100FPS', 48), ('k48000FPS', 49), ('userDef', 50), ('kUserDef', 50), ('last', 51), ('kLast', 51)], multiKeys=True)"},
            'pymelMethods': {'unit': 'getUnit', 'value': 'getValue'}},
  'MTimeArray': {'enums': {},
                 'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                 ('setLength', 'length')],
                 'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A reference to the indicated element ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MTime'},
                                              'returnType': 'MTime',
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned']},
                                              'types': {'index': 'uint'}},
                                             {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nNO SCRIPT SUPPORT. \n',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A reference to the indicated element ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MTime'},
                                              'returnType': 'MTime',
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned']},
                                              'types': {'index': 'uint'}}],
                             'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                 'type': 'MTime'}},
                                         'args': [('element',
                                                   'MTime',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                         'inArgs': ['element'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'element': ['const',
                                                                        '&']},
                                         'types': {'element': 'MTime'}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'clear': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                             'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                              'type': 'MTimeArray'}},
                                       'args': [('source',
                                                 'MTimeArray',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nCopy the contents of the source array to this array.',
                                       'inArgs': ['source'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'source': ['const',
                                                                     '&']},
                                       'types': {'source': 'MTimeArray'}}],
                             'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                            'type': 'MTime__array'}},
                                      'args': [('array',
                                                'MTime__array',
                                                'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nNO SCRIPT SUPPORT. \n',
                                      'inArgs': [],
                                      'outArgs': ['array'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'array': []},
                                      'types': {'array': 'MTime__array'}}],
                             'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                 'type': 'MTime'},
                                                     'index': {'doc': 'the index of the element to set to the the new value',
                                                               'type': 'uint'}},
                                         'args': [('element',
                                                   'MTime',
                                                   'in'),
                                                  ('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                         'inArgs': ['element', 'index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'element': ['const',
                                                                        '&'],
                                                            'index': ['unsigned']},
                                         'types': {'element': 'MTime',
                                                   'index': 'uint'}}],
                             'length': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the number of elements in the instance.',
                                         'inArgs': [],
                                         'inverse': ('setLength', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                               'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                         'inArgs': ['index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'index': ['unsigned']},
                                         'types': {'index': 'uint'}}],
                             'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                              'type': 'MTime'},
                                                  'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                            'type': 'uint'}},
                                      'args': [('element',
                                                'MTime',
                                                'in'),
                                               ('index', 'uint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nSets the value of the indicated element to the indicated  MTime  value.',
                                      'inArgs': ['element', 'index'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'element': ['const',
                                                                     '&'],
                                                         'index': ['unsigned']},
                                      'types': {'element': 'MTime',
                                                'index': 'uint'}}],
                             'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                   'type': 'uint'}},
                                            'args': [('length',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                            'inArgs': ['length'],
                                            'inverse': ('length', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'length': ['unsigned']},
                                            'types': {'length': 'uint'}}],
                             'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                'type': 'uint'}},
                                                   'args': [('newIncrement',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                   'inArgs': ['newIncrement'],
                                                   'inverse': ('sizeIncrement',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'newIncrement': ['unsigned']},
                                                   'types': {'newIncrement': 'uint'}}],
                             'sizeIncrement': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                'inArgs': [],
                                                'inverse': ('setSizeIncrement',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'length': 'getLength',
                                  'sizeIncrement': 'getSizeIncrement'}},
  'MTimer': {'enums': {},
             'methods': {'__eq__': [{'argInfo': {'rhs': {'doc': 'The timer to compare with. ',
                                                         'type': 'MTimer'}},
                                     'args': [('rhs', 'MTimer', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nEquality operator. Checks whether the start time and end time are same.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'rhs': ['const',
                                                                '&']},
                                     'types': {'rhs': 'MTimer'}}],
                         '__ne__': [{'argInfo': {'rhs': {'doc': 'The timer to compare with. ',
                                                         'type': 'MTimer'}},
                                     'args': [('rhs', 'MTimer', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nInEquality operator.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'bool'},
                                     'returnType': 'bool',
                                     'static': False,
                                     'typeQualifiers': {'rhs': ['const',
                                                                '&']},
                                     'types': {'rhs': 'MTimer'}}],
                         'beginTimer': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nThe call to this function starts the timer. \r\n  Reprocessed example  \n Examples: \n \n   \n threadTestCmd.cpp , and  threadTestWithLocksCmd.cpp . \n \n',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                         'clear': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\r\nThis function resets the member variables so that same  MTimer  object can be used to time other portions of the code. \r\n',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                         'elapsedTime': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThis function returns the time elapsed between the calls to beginTimer and endTimer. \r\n  Reprocessed example  \n Examples: \n \n   \n threadTestCmd.cpp , and  threadTestWithLocksCmd.cpp . \n \n',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                         'endTimer': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe call to this function ends the timer. \r\n  Reprocessed example  \n Examples: \n \n   \n threadTestCmd.cpp , and  threadTestWithLocksCmd.cpp . \n \n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
             'pymelEnums': {}},
  'MTimerMessage': {'enums': {},
                    'invertibles': [('setSleepCallback', 'sleepCallback')],
                    'methods': {'addTimerCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                 'type': 'void'},
                                                                  'func': {'doc': 'the callback function  elapsedTime The elapsed time since this function was last called  lastTime The execution time of this function the last time it was called  clientData User defined data passed to the callback function  ',
                                                                           'type': ('MMessage',
                                                                                    'MElapsedTimeFunction')},
                                                                  'period': {'doc': 'the period at which the callback will be executed (Measured in seconds) ',
                                                                             'type': 'float'}},
                                                      'args': [('period',
                                                                'float',
                                                                'in'),
                                                               ('func',
                                                                ('MMessage',
                                                                 'MElapsedTimeFunction'),
                                                                'in'),
                                                               ('clientData',
                                                                'void',
                                                                'in')],
                                                      'defaults': {'clientData': None},
                                                      'deprecated': False,
                                                      'doc': '\nThis method registers a callback which is called repeatedly with a specified period of time between calls. Each time the timer fires the callback will be placed on the idle queue for execution in the next idle cycle. If the timer fires again, before the previous invocation has completed execution, the new firing will be skipped.',
                                                      'inArgs': ['period',
                                                                 'func',
                                                                 'clientData'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                     'qualifiers': [],
                                                                     'type': 'MCallbackId'},
                                                      'returnType': 'MCallbackId',
                                                      'static': True,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'clientData': ['*'],
                                                                         'func': [],
                                                                         'period': []},
                                                      'types': {'clientData': 'void',
                                                                'func': ('MMessage',
                                                                         'MElapsedTimeFunction'),
                                                                'period': 'float'}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nReturns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'setSleepCallback': [{'argInfo': {'sleepFunc': {'doc': 'a function pointer to a function that will cause the current process to sleep',
                                                                                'type': 'sleepCallbackPtr'}},
                                                      'args': [('sleepFunc',
                                                                'sleepCallbackPtr',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': True,
                                                      'doc': '\n This method is obsolete. \n',
                                                      'inArgs': ['sleepFunc'],
                                                      'inverse': ('sleepCallback',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': True,
                                                      'typeQualifiers': {'sleepFunc': []},
                                                      'types': {'sleepFunc': 'sleepCallbackPtr'}}],
                                'sleepCallback': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': True,
                                                   'doc': '\n This method is obsolete. \n',
                                                   'inArgs': [],
                                                   'inverse': ('setSleepCallback',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': ('MTimerMessage',
                                                                           'sleepCallbackPtr')},
                                                   'returnType': ('MTimerMessage',
                                                                  'sleepCallbackPtr'),
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'sleepCallback': 'getSleepCallback'}},
  'MToolsInfo': {'enums': {},
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'isDirty': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nThis method returns whether or not the dirty flag is set.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                             'resetDirtyFlag': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method resets the dirty flag, such that the state becomes clean. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                             'setDirtyFlag': [{'argInfo': {'context': {'doc': 'the context whose value has changed ',
                                                                       'type': 'MPxContext'}},
                                               'args': [('context',
                                                         'MPxContext',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nThis method should be called by a tool when the value of a tool property sheet option has changed. The dirty flag will only be set if this is the current tool.',
                                               'inArgs': ['context'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': True,
                                               'typeQualifiers': {'context': ['const',
                                                                              '&']},
                                               'types': {'context': 'MPxContext'}}]},
                 'pymelEnums': {}},
  'MTransformationMatrix': {'enums': {'RotationOrder': {'valueDocs': {'XYZ': '',
                                                                      'XZY': '',
                                                                      'YXZ': '',
                                                                      'YZX': '',
                                                                      'ZXY': '',
                                                                      'ZYX': '',
                                                                      'invalid': '',
                                                                      'kInvalid': '',
                                                                      'kLast': '',
                                                                      'kXYZ': '',
                                                                      'kXZY': '',
                                                                      'kYXZ': '',
                                                                      'kYZX': '',
                                                                      'kZXY': '',
                                                                      'kZYX': '',
                                                                      'last': ''},
                                                        'values': "Enum('RotationOrder', {'kInvalid': 0, 'kXYZ': 1, 'kYZX': 2, 'kZXY': 3, 'kXZY': 4, 'kYXZ': 5, 'kZYX': 6, 'kLast': 7})"}},
                            'invertibles': [('setScale', 'getScale'),
                                            ('setScalePivot', 'scalePivot'),
                                            ('setRotatePivotTranslation',
                                             'rotatePivotTranslation'),
                                            ('setRotation', 'rotation'),
                                            ('setTranslation',
                                             'translation'),
                                            ('setRotatePivot',
                                             'rotatePivot'),
                                            ('setRotationOrientation',
                                             'rotationOrientation'),
                                            ('setShear', 'getShear'),
                                            ('setScalePivotTranslation',
                                             'scalePivotTranslation'),
                                            ('setRotationQuaternion',
                                             'getRotationQuaternion')],
                            'methods': {'__eq__': [{'argInfo': {'other': {'doc': 'transform matrix to test against',
                                                                          'type': 'MTransformationMatrix'}},
                                                    'args': [('other',
                                                              'MTransformationMatrix',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nEquality operator.',
                                                    'inArgs': ['other'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True if equal ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'other': ['const',
                                                                                 '&']},
                                                    'types': {'other': 'MTransformationMatrix'}}],
                                        '__ne__': [{'argInfo': {'other': {'doc': 'transform matrix to test against',
                                                                          'type': 'MTransformationMatrix'}},
                                                    'args': [('other',
                                                              'MTransformationMatrix',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nInequality operator.',
                                                    'inArgs': ['other'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'True if not equal ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'other': ['const',
                                                                                 '&']},
                                                    'types': {'other': 'MTransformationMatrix'}}],
                                        'addRotation': [{'argInfo': {'order': {'doc': 'order in which to apply the rotation components ',
                                                                               'type': ('MTransformationMatrix',
                                                                                        'RotationOrder')},
                                                                     'rot': {'doc': 'relative value to rotate by ',
                                                                             'type': 'double__array3'},
                                                                     'space': {'doc': 'transform space in which to perform the rotation',
                                                                               'type': ('MSpace',
                                                                                        'Space')}},
                                                         'args': [('rot',
                                                                   'double__array3',
                                                                   'in'),
                                                                  ('order',
                                                                   ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                                   'in'),
                                                                  ('space',
                                                                   ('MSpace',
                                                                    'Space'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nAdd to the rotation component by rotating relative to the existing transformation. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kPreTransform . All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                         'inArgs': ['rot',
                                                                    'order',
                                                                    'space'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'order': [],
                                                                            'rot': ['const'],
                                                                            'space': []},
                                                         'types': {'order': ('MTransformationMatrix',
                                                                             'RotationOrder'),
                                                                   'rot': 'double__array3',
                                                                   'space': ('MSpace',
                                                                             'Space')}}],
                                        'addRotationQuaternion': [{'argInfo': {'space': {'doc': 'transformation space in which to perform the operation',
                                                                                         'type': ('MSpace',
                                                                                                  'Space')},
                                                                               'w': {'doc': 'w component of quaternion ',
                                                                                     'type': 'double'},
                                                                               'x': {'doc': 'x component of quaternion ',
                                                                                     'type': 'double'},
                                                                               'y': {'doc': 'y component of quaternion ',
                                                                                     'type': 'double'},
                                                                               'z': {'doc': 'z component of quaternion ',
                                                                                     'type': 'double'}},
                                                                   'args': [('x',
                                                                             'double',
                                                                             'in'),
                                                                            ('y',
                                                                             'double',
                                                                             'in'),
                                                                            ('z',
                                                                             'double',
                                                                             'in'),
                                                                            ('w',
                                                                             'double',
                                                                             'in'),
                                                                            ('space',
                                                                             ('MSpace',
                                                                              'Space'),
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nAdd to the rotation component by rotating relative to the existing transformation. Rotation is a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kPreTransform . All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                                   'inArgs': ['x',
                                                                              'y',
                                                                              'z',
                                                                              'w',
                                                                              'space'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'space': [],
                                                                                      'w': [],
                                                                                      'x': [],
                                                                                      'y': [],
                                                                                      'z': []},
                                                                   'types': {'space': ('MSpace',
                                                                                       'Space'),
                                                                             'w': 'double',
                                                                             'x': 'double',
                                                                             'y': 'double',
                                                                             'z': 'double'}}],
                                        'addScale': [{'argInfo': {'scale': {'doc': 'relative value to scale by ',
                                                                            'type': 'double__array3'},
                                                                  'space': {'doc': 'transform space in which to perform the scale',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('scale',
                                                                'double__array3',
                                                                'in'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdd to the scale component by scaling relative to the existing transformation.',
                                                      'inArgs': ['scale',
                                                                 'space'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'scale': ['const'],
                                                                         'space': []},
                                                      'types': {'scale': 'double__array3',
                                                                'space': ('MSpace',
                                                                          'Space')}}],
                                        'addShear': [{'argInfo': {'shear': {'doc': 'relative value to shear by ',
                                                                            'type': 'double__array3'},
                                                                  'space': {'doc': 'transform space in which to perform the shear',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('shear',
                                                                'double__array3',
                                                                'in'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdd to the shear component by shearing relative to the existing transformation.',
                                                      'inArgs': ['shear',
                                                                 'space'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'shear': ['const'],
                                                                         'space': []},
                                                      'types': {'shear': 'double__array3',
                                                                'space': ('MSpace',
                                                                          'Space')}}],
                                        'addTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to perform the scale',
                                                                                  'type': ('MSpace',
                                                                                           'Space')},
                                                                        'vector': {'doc': 'relative value to translate by ',
                                                                                   'type': 'MVector'}},
                                                            'args': [('vector',
                                                                      'MVector',
                                                                      'in'),
                                                                     ('space',
                                                                      ('MSpace',
                                                                       'Space'),
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nAdd to the translation component by translating relative to the existing transformation.',
                                                            'inArgs': ['vector',
                                                                       'space'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'space': [],
                                                                               'vector': ['const',
                                                                                          '&']},
                                                            'types': {'space': ('MSpace',
                                                                                'Space'),
                                                                      'vector': 'MVector'}}],
                                        'asMatrix': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the four by four matrix that describes this transformation',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The matrix ',
                                                                     'qualifiers': [],
                                                                     'type': 'MMatrix'},
                                                      'returnType': 'MMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}},
                                                     {'argInfo': {'percent': {'doc': 'percent of the transformation to return',
                                                                              'type': 'double'}},
                                                      'args': [('percent',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns a matrix that represents the specified percentage of this transformation matrix.',
                                                      'inArgs': ['percent'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The percentage matrix ',
                                                                     'qualifiers': [],
                                                                     'type': 'MMatrix'},
                                                      'returnType': 'MMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'percent': []},
                                                      'types': {'percent': 'double'}}],
                                        'asMatrixInverse': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReturns the inverse of the four by four matrix that describes this transformation.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': 'MMatrix'},
                                                             'returnType': 'MMatrix',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                        'asRotateMatrix': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns rotate space matrix. The rotate space matrix takes points from object space to the space immediately following the scale/shear/rotation transformations.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The rotate space matrix ',
                                                                           'qualifiers': [],
                                                                           'type': 'MMatrix'},
                                                            'returnType': 'MMatrix',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                        'asScaleMatrix': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns scale space matrix. The scale space matrix takes points from object space to the space immediately following scale and shear transformations.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'MMatrix'},
                                                           'returnType': 'MMatrix',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                        'className': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nReturns the name of this class.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'char'},
                                                       'returnType': 'char',
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        'eulerRotation': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns the rotation component of the transformation matrix as an euler rotation.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'MEulerRotation'},
                                                           'returnType': 'MEulerRotation',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                        'getRotation': [{'argInfo': {'order': {'doc': 'storage for the rotation order',
                                                                               'type': ('MTransformationMatrix',
                                                                                        'RotationOrder')},
                                                                     'rot': {'doc': 'storage for the rotation in radians ',
                                                                             'type': 'double__array3'}},
                                                         'args': [('rot',
                                                                   'double__array3',
                                                                   'out'),
                                                                  ('order',
                                                                   ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                                   'out')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGet the rotation component of the transformation matrix in radians. The rotation is retrieved in  MSpace::kTransform  space.',
                                                         'inArgs': [],
                                                         'outArgs': ['rot',
                                                                     'order'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'order': ['&'],
                                                                            'rot': []},
                                                         'types': {'order': ('MTransformationMatrix',
                                                                             'RotationOrder'),
                                                                   'rot': 'double__array3'}},
                                                        {'argInfo': {'order': {'doc': 'storage for the rotation order ',
                                                                               'type': ('MTransformationMatrix',
                                                                                        'RotationOrder')},
                                                                     'rot': {'doc': 'storage for the rotation in radians ',
                                                                             'type': 'double__array3'},
                                                                     'space': {'doc': 'transform space in which to get the rotation',
                                                                               'type': ('MSpace',
                                                                                        'Space')}},
                                                         'args': [('rot',
                                                                   'double__array3',
                                                                   'out'),
                                                                  ('order',
                                                                   ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                                   'out'),
                                                                  ('space',
                                                                   ('MSpace',
                                                                    'Space'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': True,
                                                         'doc': '\n This method is obsolete. \n',
                                                         'inArgs': ['space'],
                                                         'outArgs': ['rot',
                                                                     'order'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'order': ['&'],
                                                                            'rot': [],
                                                                            'space': []},
                                                         'types': {'order': ('MTransformationMatrix',
                                                                             'RotationOrder'),
                                                                   'rot': 'double__array3',
                                                                   'space': ('MSpace',
                                                                             'Space')}}],
                                        'getRotationQuaternion': [{'argInfo': {'w': {'doc': 'storage for the w component of the quaternion',
                                                                                     'type': 'double'},
                                                                               'x': {'doc': 'storage for the x component of the quaternion ',
                                                                                     'type': 'double'},
                                                                               'y': {'doc': 'storage for the y component of the quaternion ',
                                                                                     'type': 'double'},
                                                                               'z': {'doc': 'storage for the z component of the quaternion ',
                                                                                     'type': 'double'}},
                                                                   'args': [('x',
                                                                             'double',
                                                                             'out'),
                                                                            ('y',
                                                                             'double',
                                                                             'out'),
                                                                            ('z',
                                                                             'double',
                                                                             'out'),
                                                                            ('w',
                                                                             'double',
                                                                             'out')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nGet the rotation component of the transformation matrix as a quaternion. The rotation is retrieved in  MSpace::kTransform  space.',
                                                                   'inArgs': [],
                                                                   'inverse': ('setRotationQuaternion',
                                                                               False),
                                                                   'outArgs': ['x',
                                                                               'y',
                                                                               'z',
                                                                               'w'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'w': ['&'],
                                                                                      'x': ['&'],
                                                                                      'y': ['&'],
                                                                                      'z': ['&']},
                                                                   'types': {'w': 'double',
                                                                             'x': 'double',
                                                                             'y': 'double',
                                                                             'z': 'double'}},
                                                                  {'argInfo': {'space': {'doc': 'transform space in which to get the rotation',
                                                                                         'type': ('MSpace',
                                                                                                  'Space')},
                                                                               'w': {'doc': 'storage for the w component of the quaternion ',
                                                                                     'type': 'double'},
                                                                               'x': {'doc': 'storage for the x component of the quaternion ',
                                                                                     'type': 'double'},
                                                                               'y': {'doc': 'storage for the y component of the quaternion ',
                                                                                     'type': 'double'},
                                                                               'z': {'doc': 'storage for the z component of the quaternion ',
                                                                                     'type': 'double'}},
                                                                   'args': [('x',
                                                                             'double',
                                                                             'out'),
                                                                            ('y',
                                                                             'double',
                                                                             'out'),
                                                                            ('z',
                                                                             'double',
                                                                             'out'),
                                                                            ('w',
                                                                             'double',
                                                                             'out'),
                                                                            ('space',
                                                                             ('MSpace',
                                                                              'Space'),
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': True,
                                                                   'doc': '\n This method is obsolete. \n',
                                                                   'inArgs': ['space'],
                                                                   'inverse': ('setRotationQuaternion',
                                                                               False),
                                                                   'outArgs': ['x',
                                                                               'y',
                                                                               'z',
                                                                               'w'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'space': [],
                                                                                      'w': ['&'],
                                                                                      'x': ['&'],
                                                                                      'y': ['&'],
                                                                                      'z': ['&']},
                                                                   'types': {'space': ('MSpace',
                                                                                       'Space'),
                                                                             'w': 'double',
                                                                             'x': 'double',
                                                                             'y': 'double',
                                                                             'z': 'double'}}],
                                        'getScale': [{'argInfo': {'scale': {'doc': 'storage for the scale component ',
                                                                            'type': 'double__array3'},
                                                                  'space': {'doc': 'transform space in which to get the scale',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('scale',
                                                                'double__array3',
                                                                'out'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the scale component of the transformation matrix.',
                                                      'inArgs': ['space'],
                                                      'inverse': ('setScale',
                                                                  False),
                                                      'outArgs': ['scale'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'scale': [],
                                                                         'space': []},
                                                      'types': {'scale': 'double__array3',
                                                                'space': ('MSpace',
                                                                          'Space')}}],
                                        'getShear': [{'argInfo': {'shear': {'doc': 'Shear. ',
                                                                            'type': 'double__array3'},
                                                                  'space': {'doc': 'Transform space in which to get the shear.',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('shear',
                                                                'double__array3',
                                                                'out'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the shear component of the transformation matrix.',
                                                      'inArgs': ['space'],
                                                      'inverse': ('setShear',
                                                                  False),
                                                      'outArgs': ['shear'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'shear': [],
                                                                         'space': []},
                                                      'types': {'shear': 'double__array3',
                                                                'space': ('MSpace',
                                                                          'Space')}}],
                                        'getTranslation': [{'argInfo': {'space': {'doc': 'space in which to perform the translation ',
                                                                                  'type': ('MSpace',
                                                                                           'Space')}},
                                                            'args': [('space',
                                                                      ('MSpace',
                                                                       'Space'),
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nReturns the translation component of the translation as a vector in centimeters.',
                                                            'inArgs': ['space'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'Translation vector in centimeters',
                                                                           'qualifiers': [],
                                                                           'type': 'MVector'},
                                                            'returnType': 'MVector',
                                                            'static': False,
                                                            'typeQualifiers': {'ReturnStatus': ['*'],
                                                                               'space': []},
                                                            'types': {'space': ('MSpace',
                                                                                'Space')}}],
                                        'isEquivalent': [{'argInfo': {'other': {'doc': 'transform matrix to test against ',
                                                                                'type': 'MTransformationMatrix'},
                                                                      'tol': {'doc': 'tolerance to test using',
                                                                              'type': 'double'}},
                                                          'args': [('other',
                                                                    'MTransformationMatrix',
                                                                    'in'),
                                                                   ('tol',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {'tol': 1e-10},
                                                          'deprecated': False,
                                                          'doc': '\r\nReturns true if this transform matrix is equivalent to the one passed in within a certain tolerance.',
                                                          'inArgs': ['other',
                                                                     'tol'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'True if equivalent ',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'other': ['const',
                                                                                       '&'],
                                                                             'tol': []},
                                                          'types': {'other': 'MTransformationMatrix',
                                                                    'tol': 'double'}}],
                                        'reorderRotation': [{'argInfo': {'order': {'doc': 'new order of the rotations',
                                                                                   'type': ('MTransformationMatrix',
                                                                                            'RotationOrder')}},
                                                             'args': [('order',
                                                                       ('MTransformationMatrix',
                                                                        'RotationOrder'),
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nReorders the x, y, and z components of the rotation of this transform. The overall rotation will remain the same. This operation is not unique, so spin information will be lost.',
                                                             'inArgs': ['order'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'order': ['const',
                                                                                          '&']},
                                                             'types': {'order': ('MTransformationMatrix',
                                                                                 'RotationOrder')}}],
                                        'rotateBy': [{'argInfo': {'q': {'doc': 'the quaternion that indicates how much the transformation matrix will be rotated by ',
                                                                        'type': 'MQuaternion'},
                                                                  'space': {'doc': 'the space in which the rotation is performed ',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('q',
                                                                'MQuaternion',
                                                                'in'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdds to the rotation component of the rotation matrix by rotating relative to the existing transformation using a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kPreTransform /MSpacekObject. All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                      'inArgs': ['q',
                                                                 'space'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A reference to the resulting transformation matrix',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MTransformationMatrix'},
                                                      'returnType': 'MTransformationMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'q': ['const',
                                                                               '&'],
                                                                         'space': []},
                                                      'types': {'q': 'MQuaternion',
                                                                'space': ('MSpace',
                                                                          'Space')}},
                                                     {'argInfo': {'e': {'doc': 'the euler rotation that indicates how much the transformation matrix will be rotated by ',
                                                                        'type': 'MEulerRotation'},
                                                                  'space': {'doc': 'the space in which the rotation is performed ',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('e',
                                                                'MEulerRotation',
                                                                'in'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nAdds to the rotation component of the rotation matrix by rotating relative to the existing transformation using an euler rotation. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kPreTransform /MSpacekObject. All other spaces are treated as being equivalent to  MSpace::kTransform .',
                                                      'inArgs': ['e',
                                                                 'space'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A reference to the resulting transformation matrix',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MTransformationMatrix'},
                                                      'returnType': 'MTransformationMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'ReturnStatus': ['*'],
                                                                         'e': ['const',
                                                                               '&'],
                                                                         'space': []},
                                                      'types': {'e': 'MEulerRotation',
                                                                'space': ('MSpace',
                                                                          'Space')}}],
                                        'rotatePivot': [{'argInfo': {'space': {'doc': 'space in which to get the pivot ',
                                                                               'type': ('MSpace',
                                                                                        'Space')}},
                                                         'args': [('space',
                                                                   ('MSpace',
                                                                    'Space'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nReturns the pivot around which the rotation is applied.',
                                                         'inArgs': ['space'],
                                                         'inverse': ('setRotatePivot',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Rotation pivot point',
                                                                        'qualifiers': [],
                                                                        'type': 'MPoint'},
                                                         'returnType': 'MPoint',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'space': []},
                                                         'types': {'space': ('MSpace',
                                                                             'Space')}}],
                                        'rotatePivotTranslation': [{'argInfo': {'space': {'doc': 'space in which to get the pivot translation ',
                                                                                          'type': ('MSpace',
                                                                                                   'Space')}},
                                                                    'args': [('space',
                                                                              ('MSpace',
                                                                               'Space'),
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nReturns the rotation pivot translation. This is the translation that is used to compensate for the movement of the rotation pivot.',
                                                                    'inArgs': ['space'],
                                                                    'inverse': ('setRotatePivotTranslation',
                                                                                False),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'Scale pivot translation',
                                                                                   'qualifiers': [],
                                                                                   'type': 'MVector'},
                                                                    'returnType': 'MVector',
                                                                    'static': False,
                                                                    'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                       'space': []},
                                                                    'types': {'space': ('MSpace',
                                                                                        'Space')}}],
                                        'rotateTo': [{'argInfo': {'q': {'doc': 'the quaternion to which the rotation component of the transformation matrix should be set',
                                                                        'type': 'MQuaternion'}},
                                                      'args': [('q',
                                                                'MQuaternion',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the rotation component of the transformation matrix using a quaternion. The rotation is performed in  MSpace::kTransform  space.',
                                                      'inArgs': ['q'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A reference to the resulting transformation matrix ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MTransformationMatrix'},
                                                      'returnType': 'MTransformationMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'q': ['const',
                                                                               '&']},
                                                      'types': {'q': 'MQuaternion'}},
                                                     {'argInfo': {'e': {'doc': 'the euler rotation to which the rotation component of the transformation matrix should be set',
                                                                        'type': 'MEulerRotation'}},
                                                      'args': [('e',
                                                                'MEulerRotation',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSets the rotation component of the transformation matrix using an euler rotation. The rotation is performed in  MSpace::kTransform  space.',
                                                      'inArgs': ['e'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'A reference to the resulting transformation matrix ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MTransformationMatrix'},
                                                      'returnType': 'MTransformationMatrix',
                                                      'static': False,
                                                      'typeQualifiers': {'e': ['const',
                                                                               '&']},
                                                      'types': {'e': 'MEulerRotation'}}],
                                        'rotation': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nReturns the rotation component of the transformation matrix as a quaternion. The rotation is returned in  MSpace::kTransform  space.',
                                                      'inArgs': [],
                                                      'inverse': ('setRotation',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'MQuaternion'},
                                                      'returnType': 'MQuaternion',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                        'rotationOrder': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturns the rotation order for the transform matrix. That is the order in which the Euler angles are applied to create the end rotation.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Rotation order',
                                                                          'qualifiers': [],
                                                                          'type': ('MTransformationMatrix',
                                                                                   'RotationOrder')},
                                                           'returnType': ('MTransformationMatrix',
                                                                          'RotationOrder'),
                                                           'static': False,
                                                           'typeQualifiers': {'ReturnStatus': ['*']},
                                                           'types': {}}],
                                        'rotationOrientation': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': '\r\nReturns the rotation orientation for the transformation matrix. The rotation orientation is the rotation that orients the local rotation space. The rotation is returned in  MSpace::kTransform  space.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setRotationOrientation',
                                                                             False),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': 'MQuaternion'},
                                                                 'returnType': 'MQuaternion',
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                        'scalePivot': [{'argInfo': {'space': {'doc': 'space in which to get the pivot ',
                                                                              'type': ('MSpace',
                                                                                       'Space')}},
                                                        'args': [('space',
                                                                  ('MSpace',
                                                                   'Space'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nReturns the pivot around which the scale is applied.',
                                                        'inArgs': ['space'],
                                                        'inverse': ('setScalePivot',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Scale pivot point',
                                                                       'qualifiers': [],
                                                                       'type': 'MPoint'},
                                                        'returnType': 'MPoint',
                                                        'static': False,
                                                        'typeQualifiers': {'ReturnStatus': ['*'],
                                                                           'space': []},
                                                        'types': {'space': ('MSpace',
                                                                            'Space')}}],
                                        'scalePivotTranslation': [{'argInfo': {'space': {'doc': 'space in which to get the pivot ',
                                                                                         'type': ('MSpace',
                                                                                                  'Space')}},
                                                                   'args': [('space',
                                                                             ('MSpace',
                                                                              'Space'),
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nReturns the scale pivot translation. This is the translation that is used to compensate for the movement of the scale pivot.',
                                                                   'inArgs': ['space'],
                                                                   'inverse': ('setScalePivotTranslation',
                                                                               False),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'Scale pivot translation',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MVector'},
                                                                   'returnType': 'MVector',
                                                                   'static': False,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'space': []},
                                                                   'types': {'space': ('MSpace',
                                                                                       'Space')}}],
                                        'setRotatePivot': [{'argInfo': {'balance': {'doc': 'whether to balance the matrix',
                                                                                    'type': 'bool'},
                                                                        'point': {'doc': 'new rotation pivot ',
                                                                                  'type': 'MPoint'},
                                                                        'space': {'doc': 'transform space in which to set the pivot ',
                                                                                  'type': ('MSpace',
                                                                                           'Space')}},
                                                            'args': [('point',
                                                                      'MPoint',
                                                                      'in'),
                                                                     ('space',
                                                                      ('MSpace',
                                                                       'Space'),
                                                                      'in'),
                                                                     ('balance',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSet the pivot around which the rotation is applied.',
                                                            'inArgs': ['point',
                                                                       'space',
                                                                       'balance'],
                                                            'inverse': ('rotatePivot',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'balance': [],
                                                                               'point': ['const',
                                                                                         '&'],
                                                                               'space': []},
                                                            'types': {'balance': 'bool',
                                                                      'point': 'MPoint',
                                                                      'space': ('MSpace',
                                                                                'Space')}}],
                                        'setRotatePivotTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to set the rotation translation',
                                                                                             'type': ('MSpace',
                                                                                                      'Space')},
                                                                                   'vector': {'doc': 'new rotation pivot translation ',
                                                                                              'type': 'MVector'}},
                                                                       'args': [('vector',
                                                                                 'MVector',
                                                                                 'in'),
                                                                                ('space',
                                                                                 ('MSpace',
                                                                                  'Space'),
                                                                                 'in')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\r\nSet the pivot translation. This component is used to preserve existing transformations when moving pivot. This method will only be useful to advanced users.',
                                                                       'inArgs': ['vector',
                                                                                  'space'],
                                                                       'inverse': ('rotatePivotTranslation',
                                                                                   True),
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'space': [],
                                                                                          'vector': ['const',
                                                                                                     '&']},
                                                                       'types': {'space': ('MSpace',
                                                                                           'Space'),
                                                                                 'vector': 'MVector'}}],
                                        'setRotation': [{'argInfo': {'order': {'doc': 'order in which to apply rotations',
                                                                               'type': ('MTransformationMatrix',
                                                                                        'RotationOrder')},
                                                                     'rot': {'doc': 'new rotation component in radians ',
                                                                             'type': 'double__array3'}},
                                                         'args': [('rot',
                                                                   'double__array3',
                                                                   'in'),
                                                                  ('order',
                                                                   ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSet the rotation component of the transformation matrix. The rotation is set in  MSpace::kTransform  space.',
                                                         'inArgs': ['rot',
                                                                    'order'],
                                                         'inverse': ('rotation',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'order': [],
                                                                            'rot': ['const']},
                                                         'types': {'order': ('MTransformationMatrix',
                                                                             'RotationOrder'),
                                                                   'rot': 'double__array3'}},
                                                        {'argInfo': {'order': {'doc': 'order in which to apply rotations ',
                                                                               'type': ('MTransformationMatrix',
                                                                                        'RotationOrder')},
                                                                     'rot': {'doc': 'new rotation component ',
                                                                             'type': 'double__array3'},
                                                                     'space': {'doc': 'transform space in which to perform the rotation',
                                                                               'type': ('MSpace',
                                                                                        'Space')}},
                                                         'args': [('rot',
                                                                   'double__array3',
                                                                   'in'),
                                                                  ('order',
                                                                   ('MTransformationMatrix',
                                                                    'RotationOrder'),
                                                                   'in'),
                                                                  ('space',
                                                                   ('MSpace',
                                                                    'Space'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': True,
                                                         'doc': '\n This method is obsolete. \n',
                                                         'inArgs': ['rot',
                                                                    'order',
                                                                    'space'],
                                                         'inverse': ('rotation',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'order': [],
                                                                            'rot': ['const'],
                                                                            'space': []},
                                                         'types': {'order': ('MTransformationMatrix',
                                                                             'RotationOrder'),
                                                                   'rot': 'double__array3',
                                                                   'space': ('MSpace',
                                                                             'Space')}}],
                                        'setRotationOrientation': [{'argInfo': {'q': {'doc': 'Rotation quaternion.',
                                                                                      'type': 'MQuaternion'}},
                                                                    'args': [('q',
                                                                              'MQuaternion',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': '\r\nSets the rotation orientation for the transformation matrix. The rotation orientation is the rotation that orients the local rotation space. The rotation is set in  MSpace::kTransform  space.',
                                                                    'inArgs': ['q'],
                                                                    'inverse': ('rotationOrientation',
                                                                                True),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'Rotation orientation ',
                                                                                   'qualifiers': ['&'],
                                                                                   'type': 'MTransformationMatrix'},
                                                                    'returnType': 'MTransformationMatrix',
                                                                    'static': False,
                                                                    'typeQualifiers': {'q': ['const',
                                                                                             '&']},
                                                                    'types': {'q': 'MQuaternion'}}],
                                        'setRotationQuaternion': [{'argInfo': {'w': {'doc': 'w component of new quaternion',
                                                                                     'type': 'double'},
                                                                               'x': {'doc': 'x component of new quaternion ',
                                                                                     'type': 'double'},
                                                                               'y': {'doc': 'y component of new quaternion ',
                                                                                     'type': 'double'},
                                                                               'z': {'doc': 'z component of new quaternion ',
                                                                                     'type': 'double'}},
                                                                   'args': [('x',
                                                                             'double',
                                                                             'in'),
                                                                            ('y',
                                                                             'double',
                                                                             'in'),
                                                                            ('z',
                                                                             'double',
                                                                             'in'),
                                                                            ('w',
                                                                             'double',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nSet the rotation component of the transformation matrix using a quaternion. The rotation is set in  MSpace::kTransform  space.',
                                                                   'inArgs': ['x',
                                                                              'y',
                                                                              'z',
                                                                              'w'],
                                                                   'inverse': ('getRotationQuaternion',
                                                                               True),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'w': [],
                                                                                      'x': [],
                                                                                      'y': [],
                                                                                      'z': []},
                                                                   'types': {'w': 'double',
                                                                             'x': 'double',
                                                                             'y': 'double',
                                                                             'z': 'double'}},
                                                                  {'argInfo': {'space': {'doc': 'transform space in which to perform the rotation',
                                                                                         'type': ('MSpace',
                                                                                                  'Space')},
                                                                               'w': {'doc': 'w component of new quaternion ',
                                                                                     'type': 'double'},
                                                                               'x': {'doc': 'x component of new quaternion ',
                                                                                     'type': 'double'},
                                                                               'y': {'doc': 'y component of new quaternion ',
                                                                                     'type': 'double'},
                                                                               'z': {'doc': 'z component of new quaternion ',
                                                                                     'type': 'double'}},
                                                                   'args': [('x',
                                                                             'double',
                                                                             'in'),
                                                                            ('y',
                                                                             'double',
                                                                             'in'),
                                                                            ('z',
                                                                             'double',
                                                                             'in'),
                                                                            ('w',
                                                                             'double',
                                                                             'in'),
                                                                            ('space',
                                                                             ('MSpace',
                                                                              'Space'),
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': True,
                                                                   'doc': '\n This method is obsolete. \n',
                                                                   'inArgs': ['x',
                                                                              'y',
                                                                              'z',
                                                                              'w',
                                                                              'space'],
                                                                   'inverse': ('getRotationQuaternion',
                                                                               True),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'space': [],
                                                                                      'w': [],
                                                                                      'x': [],
                                                                                      'y': [],
                                                                                      'z': []},
                                                                   'types': {'space': ('MSpace',
                                                                                       'Space'),
                                                                             'w': 'double',
                                                                             'x': 'double',
                                                                             'y': 'double',
                                                                             'z': 'double'}}],
                                        'setScale': [{'argInfo': {'scale': {'doc': 'new scale component ',
                                                                            'type': 'double__array3'},
                                                                  'space': {'doc': 'transform space in which to perform the scale',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('scale',
                                                                'double__array3',
                                                                'in'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the scale component of the transformation matrix.',
                                                      'inArgs': ['scale',
                                                                 'space'],
                                                      'inverse': ('getScale',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'scale': ['const'],
                                                                         'space': []},
                                                      'types': {'scale': 'double__array3',
                                                                'space': ('MSpace',
                                                                          'Space')}}],
                                        'setScalePivot': [{'argInfo': {'balance': {'doc': 'whether to balance the matrix',
                                                                                   'type': 'bool'},
                                                                       'point': {'doc': 'new scale pivot ',
                                                                                 'type': 'MPoint'},
                                                                       'space': {'doc': 'transform space in which to set the scale pivot ',
                                                                                 'type': ('MSpace',
                                                                                          'Space')}},
                                                           'args': [('point',
                                                                     'MPoint',
                                                                     'in'),
                                                                    ('space',
                                                                     ('MSpace',
                                                                      'Space'),
                                                                     'in'),
                                                                    ('balance',
                                                                     'bool',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSet the pivot around which the scale is applied.',
                                                           'inArgs': ['point',
                                                                      'space',
                                                                      'balance'],
                                                           'inverse': ('scalePivot',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'balance': [],
                                                                              'point': ['const',
                                                                                        '&'],
                                                                              'space': []},
                                                           'types': {'balance': 'bool',
                                                                     'point': 'MPoint',
                                                                     'space': ('MSpace',
                                                                               'Space')}}],
                                        'setScalePivotTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to set the scale translation',
                                                                                            'type': ('MSpace',
                                                                                                     'Space')},
                                                                                  'vector': {'doc': 'new scale pivot translation ',
                                                                                             'type': 'MVector'}},
                                                                      'args': [('vector',
                                                                                'MVector',
                                                                                'in'),
                                                                               ('space',
                                                                                ('MSpace',
                                                                                 'Space'),
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': '\r\nSet the pivot translation. This component is used to preserve existing scale transformations when moving pivot. This method will only be useful to advanced users.',
                                                                      'inArgs': ['vector',
                                                                                 'space'],
                                                                      'inverse': ('scalePivotTranslation',
                                                                                  True),
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': None},
                                                                      'returnType': None,
                                                                      'static': False,
                                                                      'typeQualifiers': {'space': [],
                                                                                         'vector': ['const',
                                                                                                    '&']},
                                                                      'types': {'space': ('MSpace',
                                                                                          'Space'),
                                                                                'vector': 'MVector'}}],
                                        'setShear': [{'argInfo': {'shear': {'doc': 'new shear component ',
                                                                            'type': 'double__array3'},
                                                                  'space': {'doc': 'transform space in which to perform the shear',
                                                                            'type': ('MSpace',
                                                                                     'Space')}},
                                                      'args': [('shear',
                                                                'double__array3',
                                                                'in'),
                                                               ('space',
                                                                ('MSpace',
                                                                 'Space'),
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nSet the shear component of the transformation matrix. The shear values represent (xy, xz, yx).',
                                                      'inArgs': ['shear',
                                                                 'space'],
                                                      'inverse': ('getShear',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'shear': ['const'],
                                                                         'space': []},
                                                      'types': {'shear': 'double__array3',
                                                                'space': ('MSpace',
                                                                          'Space')}}],
                                        'setToRotationAxis': [{'argInfo': {'axis': {'doc': 'axis to rotate about ',
                                                                                    'type': 'MVector'},
                                                                           'rotation': {'doc': 'rotation in radians',
                                                                                        'type': 'double'}},
                                                               'args': [('axis',
                                                                         'MVector',
                                                                         'in'),
                                                                        ('rotation',
                                                                         'double',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nSets the rotation given an axis and a rotation about it.',
                                                               'inArgs': ['axis',
                                                                          'rotation'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'axis': ['const',
                                                                                           '&'],
                                                                                  'rotation': []},
                                                               'types': {'axis': 'MVector',
                                                                         'rotation': 'double'}}],
                                        'setTranslation': [{'argInfo': {'space': {'doc': 'transform space in which to perform the translation',
                                                                                  'type': ('MSpace',
                                                                                           'Space')},
                                                                        'vector': {'doc': 'new translation component in centimeters. ',
                                                                                   'type': 'MVector'}},
                                                            'args': [('vector',
                                                                      'MVector',
                                                                      'in'),
                                                                     ('space',
                                                                      ('MSpace',
                                                                       'Space'),
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSet the translation component of the transformation matrix in centimeters.',
                                                            'inArgs': ['vector',
                                                                       'space'],
                                                            'inverse': ('translation',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'space': [],
                                                                               'vector': ['const',
                                                                                          '&']},
                                                            'types': {'space': ('MSpace',
                                                                                'Space'),
                                                                      'vector': 'MVector'}}],
                                        'translation': [{'argInfo': {'space': {'doc': 'space in which to perform the translation ',
                                                                               'type': ('MSpace',
                                                                                        'Space')}},
                                                         'args': [('space',
                                                                   ('MSpace',
                                                                    'Space'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': True,
                                                         'doc': '\n This method is obsolete. \n',
                                                         'inArgs': ['space'],
                                                         'inverse': ('setTranslation',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Translation vector in centimeters',
                                                                        'qualifiers': [],
                                                                        'type': 'MVector'},
                                                         'returnType': 'MVector',
                                                         'static': False,
                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                            'space': []},
                                                         'types': {'space': ('MSpace',
                                                                             'Space')}}]},
                            'pymelEnums': {'RotationOrder': "Enum('RotationOrder', [('invalid', 0), ('kInvalid', 0), ('XYZ', 1), ('kXYZ', 1), ('YZX', 2), ('kYZX', 2), ('ZXY', 3), ('kZXY', 3), ('XZY', 4), ('kXZY', 4), ('YXZ', 5), ('kYXZ', 5), ('ZYX', 6), ('kZYX', 6), ('last', 7), ('kLast', 7)], multiKeys=True)"},
                            'pymelMethods': {'rotatePivot': 'getRotatePivot',
                                             'rotatePivotTranslation': 'getRotatePivotTranslation',
                                             'rotation': 'getRotation',
                                             'rotationOrientation': 'getRotationOrientation',
                                             'scalePivot': 'getScalePivot',
                                             'scalePivotTranslation': 'getScalePivotTranslation',
                                             'translation': 'getTranslation'}},
  'MTrimBoundaryArray': {'enums': {},
                         'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'value indicating which array to return',
                                                                            'type': 'uint'}},
                                                      'args': [('index',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nThe index operator. NOTE: no bounds are checked by this method.',
                                                      'inArgs': ['index'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The MObjectArray requested ',
                                                                     'qualifiers': ['&'],
                                                                     'type': 'MObjectArray'},
                                                      'returnType': 'MObjectArray',
                                                      'static': False,
                                                      'typeQualifiers': {'index': ['unsigned']},
                                                      'types': {'index': 'uint'}}],
                                     'append': [{'argInfo': {'boundary': {'doc': 'the boundary array to append',
                                                                          'type': 'MObjectArray'}},
                                                 'args': [('boundary',
                                                           'MObjectArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nAdd a new boundary array at the end of the list.',
                                                 'inArgs': ['boundary'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'boundary': ['const',
                                                                                 '&']},
                                                 'types': {'boundary': 'MObjectArray'}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nReturns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'clear': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nThis method clears the trim boundary array.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                     'get': [{'argInfo': {'index': {'doc': 'value indicating which array to return',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nThe method returns the  MObjectArray  specified by the index. NOTE: no bounds are checked by this method.',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The MObjectArray requested ',
                                                             'qualifiers': ['&'],
                                                             'type': 'MObjectArray'},
                                              'returnType': 'MObjectArray',
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned']},
                                              'types': {'index': 'uint'}}],
                                     'getMergedBoundary': [{'argInfo': {'index': {'doc': 'the index to the boundary array that should be used to create the curve ',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\nThis function create a curve that represent all curves of the boundary. The original boundary edges are not changed. Note that the resulting curve is not added to the current model but is owned by an  MObject  which is of type kNurbsCurveData.',
                                                            'inArgs': ['index'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': ' MS::kSuccess if the curve creation worked and MS::kFailure otherwise   ',
                                                                           'qualifiers': [],
                                                                           'type': 'MObject'},
                                                            'returnType': 'MObject',
                                                            'static': False,
                                                            'typeQualifiers': {'index': ['unsigned'],
                                                                               'status': ['*']},
                                                            'types': {'index': 'uint'}}],
                                     'insert': [{'argInfo': {'boundary': {'doc': 'the object array to add ',
                                                                          'type': 'MObjectArray'},
                                                             'index': {'doc': 'the index to add the boundary array at',
                                                                       'type': 'uint'}},
                                                 'args': [('boundary',
                                                           'MObjectArray',
                                                           'in'),
                                                          ('index',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nThis method adds a new boundary into the "index" position.',
                                                 'inArgs': ['boundary',
                                                            'index'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'boundary': ['const',
                                                                                 '&'],
                                                                    'index': ['unsigned']},
                                                 'types': {'boundary': 'MObjectArray',
                                                           'index': 'uint'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nThis method returns the length of the trim boundary array. \n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                     'remove': [{'argInfo': {'index': {'doc': 'the index of the array to remove',
                                                                       'type': 'uint'}},
                                                 'args': [('index',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nThis method removes an existing boundary from the list.',
                                                 'inArgs': ['index'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'index': ['unsigned']},
                                                 'types': {'index': 'uint'}}],
                                     'reserve': [{'argInfo': {'reserveLength': {'doc': 'the number of items to reserve',
                                                                                'type': 'uint'}},
                                                  'args': [('reserveLength',
                                                            'uint',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nThis method is used to reserve the capacity of the array.',
                                                  'inArgs': ['reserveLength'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'reserveLength': ['unsigned']},
                                                  'types': {'reserveLength': 'uint'}}],
                                     'set': [{'argInfo': {'boundary': {'doc': 'the boundary object array to set ',
                                                                       'type': 'MObjectArray'},
                                                          'index': {'doc': 'the index to place the boundary array at',
                                                                    'type': 'uint'}},
                                              'args': [('boundary',
                                                        'MObjectArray',
                                                        'in'),
                                                       ('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nThis method is used to replace an existing boundary array.',
                                              'inArgs': ['boundary',
                                                         'index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'boundary': ['const',
                                                                              '&'],
                                                                 'index': ['unsigned']},
                                              'types': {'boundary': 'MObjectArray',
                                                        'index': 'uint'}}],
                                     'size': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nThis method returns the size of the trim boundary array. The size and the length are the same. \n',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'int'},
                                               'returnType': 'int',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MTypeId': {'enums': {},
              'methods': {'__eq__': [{'argInfo': {'rhs': {'doc': 'MTypeId to compare with.',
                                                          'type': 'MTypeId'}},
                                      'args': [('rhs', 'MTypeId', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nEquivalence operator.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'True of the two MTypeId hold the same 32-bit binary tag. ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'rhs': ['const',
                                                                 '&']},
                                      'types': {'rhs': 'MTypeId'}}],
                          '__ne__': [{'argInfo': {'rhs': {'doc': 'MTypeId to compare with.',
                                                          'type': 'MTypeId'}},
                                      'args': [('rhs', 'MTypeId', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nInequality operator.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'True of the two MTypeId hold different 32-bit binary tags. ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'rhs': ['const',
                                                                 '&']},
                                      'types': {'rhs': 'MTypeId'}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'id': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\r\nReturn the 32 bit id tag contained in the  MTypeId  instance',
                                  'inArgs': [],
                                  'outArgs': [],
                                  'returnInfo': {'doc': 'The 32-bit id tag contained in this MTypeId instance. ',
                                                 'qualifiers': [],
                                                 'type': 'int'},
                                  'returnType': 'int',
                                  'static': False,
                                  'typeQualifiers': {'ReturnStatus': ['*']},
                                  'types': {}}]},
              'pymelEnums': {}},
  'MURI': {'enums': {},
           'invertibles': [('setUserName', 'getUserName'),
                           ('setScheme', 'getScheme'),
                           ('setFragment', 'getFragment'),
                           ('setHost', 'getHost'),
                           ('setPassword', 'getPassword'),
                           ('setPath', 'getPath'),
                           ('setDirectory', 'getDirectory'),
                           ('setAuthority', 'getAuthority'),
                           ('setFileName', 'getFileName'),
                           ('setUserInfo', 'getUserInfo'),
                           ('setPort', 'getPort')],
           'methods': {'__eq__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                       'type': 'MURI'}},
                                   'args': [('rhs', 'MURI', 'in')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\nEquality operator. Compares two  MURI  objects to see if they contain the same value.',
                                   'inArgs': ['rhs'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'true if the two objects are equivalent, false otherwise. ',
                                                  'qualifiers': [],
                                                  'type': 'bool'},
                                   'returnType': 'bool',
                                   'static': False,
                                   'typeQualifiers': {'rhs': ['const',
                                                              '&']},
                                   'types': {'rhs': 'MURI'}}],
                       '__ne__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                       'type': 'MURI'}},
                                   'args': [('rhs', 'MURI', 'in')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\nInequality operator. Compares two  MURI  objects to see if they differ.',
                                   'inArgs': ['rhs'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'true if the two objects are different, false otherwise. ',
                                                  'qualifiers': [],
                                                  'type': 'bool'},
                                   'returnType': 'bool',
                                   'static': False,
                                   'typeQualifiers': {'rhs': ['const',
                                                              '&']},
                                   'types': {'rhs': 'MURI'}}],
                       'addQueryItem': [{'argInfo': {'key': {'doc': 'The key to set ',
                                                             'type': 'MString'},
                                                     'value': {'doc': 'The value to set',
                                                               'type': 'MString'}},
                                         'args': [('key',
                                                   'MString',
                                                   'in'),
                                                  ('value',
                                                   'MString',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nAdd a key/value pair to the query string of the URI.',
                                         'inArgs': ['key', 'value'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'key': ['const',
                                                                    '&'],
                                                            'value': ['const',
                                                                      '&']},
                                         'types': {'key': 'MString',
                                                   'value': 'MString'}}],
                       'asString': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\nReturns the string representation of the URI',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MString'},
                                     'returnType': 'MString',
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                       'className': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nReturns the name of this class.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['*'],
                                                     'type': 'char'},
                                      'returnType': 'char',
                                      'static': True,
                                      'typeQualifiers': {},
                                      'types': {}}],
                       'clear': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\nClears the contents of the  MURI  object. After clearing, the URI will be empty.',
                                  'inArgs': [],
                                  'outArgs': [],
                                  'returnInfo': {'doc': '',
                                                 'qualifiers': [],
                                                 'type': None},
                                  'returnType': None,
                                  'static': False,
                                  'typeQualifiers': {},
                                  'types': {}}],
                       'copy': [{'argInfo': {'other': {'doc': 'The URI object to copy.',
                                                       'type': 'MURI'}},
                                 'args': [('other', 'MURI', 'in')],
                                 'defaults': {},
                                 'deprecated': False,
                                 'doc': '\nCopy the contents of one URI object to another.',
                                 'inArgs': ['other'],
                                 'outArgs': [],
                                 'returnInfo': {'doc': '',
                                                'qualifiers': [],
                                                'type': None},
                                 'returnType': None,
                                 'static': False,
                                 'typeQualifiers': {'other': ['const',
                                                              '&']},
                                 'types': {'other': 'MURI'}}],
                       'getAllQueryItemKeys': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nReturns an array containing the keys from all query string pairs.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'MStringArray'},
                                                'returnType': 'MStringArray',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                       'getAllQueryItemValues': [{'argInfo': {'key': {'doc': 'The key to query',
                                                                      'type': 'MString'}},
                                                  'args': [('key',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns an array containing the values from all query string pairs which have a given key.',
                                                  'inArgs': ['key'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Array of query string values. ',
                                                                 'qualifiers': [],
                                                                 'type': 'MStringArray'},
                                                  'returnType': 'MStringArray',
                                                  'static': False,
                                                  'typeQualifiers': {'key': ['const',
                                                                             '&']},
                                                  'types': {'key': 'MString'}}],
                       'getAuthority': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the authority component of the URI. If the authority is undefined, an empty string is returned.',
                                         'inArgs': [],
                                         'inverse': ('setAuthority',
                                                     False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                       'getDirectory': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns just the file directory portion of the URI, without the file name. See also  getPath()  and  getFileName() .',
                                         'inArgs': [],
                                         'inverse': ('setDirectory',
                                                     False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'MString'},
                                         'returnType': 'MString',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                       'getFileName': [{'argInfo': {'includeExtension': {'doc': 'If true include the extension (e.g. "file.jpg"), otherwise do not (e.g. "file"). Its default value is true.',
                                                                         'type': 'bool'}},
                                        'args': [('includeExtension',
                                                  'bool',
                                                  'in')],
                                        'defaults': {'includeExtension': True},
                                        'deprecated': False,
                                        'doc': '\nReturns just the file name portion of the URI, with or without the extension. The file directory is not included. See also  getPath()  and  getDirectory() .',
                                        'inArgs': ['includeExtension'],
                                        'inverse': ('setFileName', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The file name defined in the URI. ',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {'includeExtension': []},
                                        'types': {'includeExtension': 'bool'}}],
                       'getFragment': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nReturns the fragment component of the URI. If the fragment is undefined, an empty string is returned.',
                                        'inArgs': [],
                                        'inverse': ('setFragment', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                       'getHost': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nReturns the host component of the URI. If the host is not defined, an empty string is returned. See also  getUserInfo() ,  getPort() .',
                                    'inArgs': [],
                                    'inverse': ('setHost', False),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'MString'},
                                    'returnType': 'MString',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                       'getPassword': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nReturns the password component of the URI. If the password is not defined, an empty string is returned. See also  getUserInfo() ,  getUserName() .',
                                        'inArgs': [],
                                        'inverse': ('setPassword', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                       'getPath': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nReturns the path component of the URI. The path of the URI is composed of the file directory and file name. See also  getFileName()  and  getDirectory()  to access the file directory and file name components of the path individually.',
                                    'inArgs': [],
                                    'inverse': ('setPath', False),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'MString'},
                                    'returnType': 'MString',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                       'getPort': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nReturns the port component of the URI, or -1 if the port is not defined. See also  getUserInfo() ,  getHost() .',
                                    'inArgs': [],
                                    'inverse': ('setPort', False),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'int'},
                                    'returnType': 'int',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                       'getQueryItemValue': [{'argInfo': {'key': {'doc': 'The key to query',
                                                                  'type': 'MString'}},
                                              'args': [('key',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the value from the first query string pair in the URI which has a given key.',
                                              'inArgs': ['key'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Query string value. ',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'key': ['const',
                                                                         '&']},
                                              'types': {'key': 'MString'}}],
                       'getQueryPairDelimiter': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturns the character used to delimit between key-value pairs in the query string of the URI.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                       'getQueryValueDelimiter': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nReturns the character used to delimit keys and values in the query string of the URI. See also  setQueryDelimiters() .',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                       'getScheme': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nReturns the scheme of the URI. An empty string is returned if the scheme is undefined or the current URI is invalid.',
                                      'inArgs': [],
                                      'inverse': ('setScheme', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'MString'},
                                      'returnType': 'MString',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                       'getUserInfo': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nReturns the user info component of the URI. If the user info is not defined, an empty string is returned. See also  getUserName() ,  getPassword() ,  getHost() ,  getPort() .',
                                        'inArgs': [],
                                        'inverse': ('setUserInfo', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                       'getUserName': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nReturns the user name component of the URI. If the user name is not defined, an empty string is returned. See also  getUserInfo() ,  getPassword() .',
                                        'inArgs': [],
                                        'inverse': ('setUserName', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': 'MString'},
                                        'returnType': 'MString',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                       'isEmpty': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nDetermines if the URI does not contain any data',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                       'isValid': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nDetermines if the URI is valid',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                       'isValidURI': [{'argInfo': {'URI': {'doc': 'the URI string to validate',
                                                           'type': 'MString'}},
                                       'args': [('URI', 'MString', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nDetermines if a string value represents a valid URI.',
                                       'inArgs': ['URI'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'true if the URI is valid, false otherwise. ',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': True,
                                       'typeQualifiers': {'URI': ['const',
                                                                  '&']},
                                       'types': {'URI': 'MString'}}],
                       'removeAllQueryItems': [{'argInfo': {'key': {'doc': 'The key of the query items to remove',
                                                                    'type': 'MString'}},
                                                'args': [('key',
                                                          'MString',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nRemoves all query string pairs having a given key from the URI.',
                                                'inArgs': ['key'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'key': ['const',
                                                                           '&']},
                                                'types': {'key': 'MString'}}],
                       'removeQueryItem': [{'argInfo': {'key': {'doc': 'The key of the query item to remove',
                                                                'type': 'MString'}},
                                            'args': [('key',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nRemoves the first query string pair with a given key from the URI.',
                                            'inArgs': ['key'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'key': ['const',
                                                                       '&']},
                                            'types': {'key': 'MString'}}],
                       'setAuthority': [{'argInfo': {'authority': {'doc': 'The authority value to set',
                                                                   'type': 'MString'}},
                                         'args': [('authority',
                                                   'MString',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': "\nSet the authority portion of the URI. Decomposes the authority string to set the authority-related component values. The user info and host are separated by a '@', and the host and port are separated by a ':'. See also  setUserName() ,  setPassword() ,  setHost()  and  setPort() .",
                                         'inArgs': ['authority'],
                                         'inverse': ('getAuthority',
                                                     True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'authority': ['const',
                                                                          '&']},
                                         'types': {'authority': 'MString'}}],
                       'setDirectory': [{'argInfo': {'directory': {'doc': 'The file directory to set',
                                                                   'type': 'MString'}},
                                         'args': [('directory',
                                                   'MString',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nSets just the directory portion of the URI (i.e. not including the filename). See also  setPath()  and  setFileName() .',
                                         'inArgs': ['directory'],
                                         'inverse': ('getDirectory',
                                                     True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'directory': ['const',
                                                                          '&']},
                                         'types': {'directory': 'MString'}}],
                       'setFileName': [{'argInfo': {'fileName': {'doc': 'The file name to set',
                                                                 'type': 'MString'}},
                                        'args': [('fileName',
                                                  'MString',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nSets just the filename portion of the URI (i.e. not including the directory). See also  setPath()  and  setDirectory() .',
                                        'inArgs': ['fileName'],
                                        'inverse': ('getFileName', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'fileName': ['const',
                                                                        '&']},
                                        'types': {'fileName': 'MString'}}],
                       'setFragment': [{'argInfo': {'fragment': {'doc': 'The fragment to set',
                                                                 'type': 'MString'}},
                                        'args': [('fragment',
                                                  'MString',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "\nSets the fragment component of the URI. The fragment is the last part of the URI, after the '#'.",
                                        'inArgs': ['fragment'],
                                        'inverse': ('getFragment', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'fragment': ['const',
                                                                        '&']},
                                        'types': {'fragment': 'MString'}}],
                       'setHost': [{'argInfo': {'host': {'doc': 'The host to set',
                                                         'type': 'MString'}},
                                    'args': [('host', 'MString', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nSet the host component of the URI. See also  setAuthority() ,  setPort()',
                                    'inArgs': ['host'],
                                    'inverse': ('getHost', True),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {'host': ['const',
                                                                '&']},
                                    'types': {'host': 'MString'}}],
                       'setPassword': [{'argInfo': {'password': {'doc': 'The password to set',
                                                                 'type': 'MString'}},
                                        'args': [('password',
                                                  'MString',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nSets the password part of the user info component. See also  setAuthority() ,  setUserInfo() ,  setUserName() .',
                                        'inArgs': ['password'],
                                        'inverse': ('getPassword', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'password': ['const',
                                                                        '&']},
                                        'types': {'password': 'MString'}}],
                       'setPath': [{'argInfo': {'path': {'doc': 'The path to set',
                                                         'type': 'MString'}},
                                    'args': [('path', 'MString', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nSets the path component of the URI. The path can contain both a directory and a file name. See also  setFileName()  and  setDirectory() .',
                                    'inArgs': ['path'],
                                    'inverse': ('getPath', True),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {'path': ['const',
                                                                '&']},
                                    'types': {'path': 'MString'}}],
                       'setPort': [{'argInfo': {'port': {'doc': 'The port to set',
                                                         'type': 'int'}},
                                    'args': [('port', 'int', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nSet the port component of the URI. See also  setAuthority() ,  setHost()',
                                    'inArgs': ['port'],
                                    'inverse': ('getPort', True),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {'port': []},
                                    'types': {'port': 'int'}}],
                       'setQueryDelimiters': [{'argInfo': {'pairDelimiter': {'doc': 'The pairDelimiter to set',
                                                                             'type': 'char'},
                                                           'valueDelimiter': {'doc': 'The valueDelimiter to set ',
                                                                              'type': 'char'}},
                                               'args': [('valueDelimiter',
                                                         'char',
                                                         'in'),
                                                        ('pairDelimiter',
                                                         'char',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nSets the delimiter characters used in the query string of the URI.',
                                               'inArgs': ['valueDelimiter',
                                                          'pairDelimiter'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'pairDelimiter': [],
                                                                  'valueDelimiter': []},
                                               'types': {'pairDelimiter': 'char',
                                                         'valueDelimiter': 'char'}}],
                       'setScheme': [{'argInfo': {'scheme': {'doc': 'The scheme to set',
                                                             'type': 'MString'}},
                                      'args': [('scheme',
                                                'MString',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "\nSets the scheme component of the URI. The scheme identifies the type of the URI. It is the first element of the URI and consists of all the characters preceeding the first ':'. The scheme is expected to contain only ASCII characters.  Parameters: \n \n [in]  scheme  The scheme to set \n \n \n Returns: MS::kSuccess  for success, otherwise  MS::kFailure   \n",
                                      'inArgs': ['scheme'],
                                      'inverse': ('getScheme', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'scheme': ['const',
                                                                    '&']},
                                      'types': {'scheme': 'MString'}}],
                       'setURI': [{'argInfo': {'URI': {'doc': 'The URI string.',
                                                       'type': 'MString'}},
                                   'args': [('URI', 'MString', 'in')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\nInitialize the  MURI  from a string value. The individual components of the URI will be set based on the contents of the string.',
                                   'inArgs': ['URI'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': None},
                                   'returnType': None,
                                   'static': False,
                                   'typeQualifiers': {'URI': ['const',
                                                              '&']},
                                   'types': {'URI': 'MString'}}],
                       'setUserInfo': [{'argInfo': {'userInfo': {'doc': 'The userInfo to set',
                                                                 'type': 'MString'}},
                                        'args': [('userInfo',
                                                  'MString',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "\nDecomposes the userInfo string to fill out the userInfo-related component values. The user info consists of a user name and password separated by a colon ':'. The password is optional, if not specified, no colon is used. See also  setAuthority() ,  setUserName() ,  setPassword() .",
                                        'inArgs': ['userInfo'],
                                        'inverse': ('getUserInfo', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'userInfo': ['const',
                                                                        '&']},
                                        'types': {'userInfo': 'MString'}}],
                       'setUserName': [{'argInfo': {'userName': {'doc': 'The user name to set',
                                                                 'type': 'MString'}},
                                        'args': [('userName',
                                                  'MString',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nSets the user name part of the user info component. See also  setAuthority() ,  setUserInfo() ,  setPassword() .',
                                        'inArgs': ['userName'],
                                        'inverse': ('getUserName', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'userName': ['const',
                                                                        '&']},
                                        'types': {'userName': 'MString'}}]},
           'pymelEnums': {}},
  'MUiMessage': {'enums': {},
                 'methods': {'add3dViewDestroyMsgCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                         'type': 'void'},
                                                                          'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that contains the 3d view.  clientData User defined data passed to the callback function   ',
                                                                                   'type': ('MMessage',
                                                                                            'MStringFunction')},
                                                                          'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                        'type': 'MString'}},
                                                              'args': [('panelName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('func',
                                                                        ('MMessage',
                                                                         'MStringFunction'),
                                                                        'in'),
                                                                       ('clientData',
                                                                        'void',
                                                                        'in')],
                                                              'defaults': {'clientData': None},
                                                              'deprecated': False,
                                                              'doc': '\r\nThis method registers a callback for when a particular 3d view gets destroyed. The callback is called before the destruction of the view.',
                                                              'inArgs': ['panelName',
                                                                         'func',
                                                                         'clientData'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                             'qualifiers': [],
                                                                             'type': 'MCallbackId'},
                                                              'returnType': 'MCallbackId',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'clientData': ['*'],
                                                                                 'func': [],
                                                                                 'panelName': ['const',
                                                                                               '&']},
                                                              'types': {'clientData': 'void',
                                                                        'func': ('MMessage',
                                                                                 'MStringFunction'),
                                                                        'panelName': 'MString'}}],
                             'add3dViewPostMultipleDrawPassMsgCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                                      'type': 'void'},
                                                                                       'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that contains the 3d view.  clientData User defined data passed to the callback function   ',
                                                                                                'type': ('MUiMessage',
                                                                                                         'MStringIndexFunction')},
                                                                                       'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                                     'type': 'MString'}},
                                                                           'args': [('panelName',
                                                                                     'MString',
                                                                                     'in'),
                                                                                    ('func',
                                                                                     ('MUiMessage',
                                                                                      'MStringIndexFunction'),
                                                                                     'in'),
                                                                                    ('clientData',
                                                                                     'void',
                                                                                     'in')],
                                                                           'defaults': {'clientData': None},
                                                                           'deprecated': False,
                                                                           'doc': "\r\nThis method registers a callback for when a particular 3d view's specified pass is finshed when multiple drawing is enabled.",
                                                                           'inArgs': ['panelName',
                                                                                      'func',
                                                                                      'clientData'],
                                                                           'outArgs': [],
                                                                           'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                          'qualifiers': [],
                                                                                          'type': 'MCallbackId'},
                                                                           'returnType': 'MCallbackId',
                                                                           'static': True,
                                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                              'clientData': ['*'],
                                                                                              'func': [],
                                                                                              'panelName': ['const',
                                                                                                            '&']},
                                                                           'types': {'clientData': 'void',
                                                                                     'func': ('MUiMessage',
                                                                                              'MStringIndexFunction'),
                                                                                     'panelName': 'MString'}}],
                             'add3dViewPostRenderMsgCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                            'type': 'void'},
                                                                             'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that contains the 3d view.  clientData User defined data passed to the callback function   ',
                                                                                      'type': ('MMessage',
                                                                                               'MStringFunction')},
                                                                             'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                           'type': 'MString'}},
                                                                 'args': [('panelName',
                                                                           'MString',
                                                                           'in'),
                                                                          ('func',
                                                                           ('MMessage',
                                                                            'MStringFunction'),
                                                                           'in'),
                                                                          ('clientData',
                                                                           'void',
                                                                           'in')],
                                                                 'defaults': {'clientData': None},
                                                                 'deprecated': False,
                                                                 'doc': "\r\nThis method registers a callback for when the 3d view is about to display it's rendered contents to the viewport. It is called for every refresh of the view, after the scene is drawn, but before any 2d adornments are drawn.",
                                                                 'inArgs': ['panelName',
                                                                            'func',
                                                                            'clientData'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                'qualifiers': [],
                                                                                'type': 'MCallbackId'},
                                                                 'returnType': 'MCallbackId',
                                                                 'static': True,
                                                                 'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                    'clientData': ['*'],
                                                                                    'func': [],
                                                                                    'panelName': ['const',
                                                                                                  '&']},
                                                                 'types': {'clientData': 'void',
                                                                           'func': ('MMessage',
                                                                                    'MStringFunction'),
                                                                           'panelName': 'MString'}}],
                             'add3dViewPreMultipleDrawPassMsgCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                                     'type': 'void'},
                                                                                      'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that contains the 3d view.  clientData User defined data passed to the callback function   ',
                                                                                               'type': ('MUiMessage',
                                                                                                        'MStringIndexFunction')},
                                                                                      'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                                    'type': 'MString'}},
                                                                          'args': [('panelName',
                                                                                    'MString',
                                                                                    'in'),
                                                                                   ('func',
                                                                                    ('MUiMessage',
                                                                                     'MStringIndexFunction'),
                                                                                    'in'),
                                                                                   ('clientData',
                                                                                    'void',
                                                                                    'in')],
                                                                          'defaults': {'clientData': None},
                                                                          'deprecated': False,
                                                                          'doc': "\r\nThis method registers a callback for when a particular 3d view's specific pass is about to be drawn when multiple drawing is enabled.",
                                                                          'inArgs': ['panelName',
                                                                                     'func',
                                                                                     'clientData'],
                                                                          'outArgs': [],
                                                                          'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                         'qualifiers': [],
                                                                                         'type': 'MCallbackId'},
                                                                          'returnType': 'MCallbackId',
                                                                          'static': True,
                                                                          'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                             'clientData': ['*'],
                                                                                             'func': [],
                                                                                             'panelName': ['const',
                                                                                                           '&']},
                                                                          'types': {'clientData': 'void',
                                                                                    'func': ('MUiMessage',
                                                                                             'MStringIndexFunction'),
                                                                                    'panelName': 'MString'}}],
                             'add3dViewPreRenderMsgCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                           'type': 'void'},
                                                                            'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that contains the 3d view.  clientData User defined data passed to the callback function   ',
                                                                                     'type': ('MMessage',
                                                                                              'MStringFunction')},
                                                                            'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                          'type': 'MString'}},
                                                                'args': [('panelName',
                                                                          'MString',
                                                                          'in'),
                                                                         ('func',
                                                                          ('MMessage',
                                                                           'MStringFunction'),
                                                                          'in'),
                                                                         ('clientData',
                                                                          'void',
                                                                          'in')],
                                                                'defaults': {'clientData': None},
                                                                'deprecated': False,
                                                                'doc': "\r\nThis method registers a callback for when a particular 3d view is about to render it's contents. It is called before the scene is drawn, but after the background has been drawn.",
                                                                'inArgs': ['panelName',
                                                                           'func',
                                                                           'clientData'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                               'qualifiers': [],
                                                                               'type': 'MCallbackId'},
                                                                'returnType': 'MCallbackId',
                                                                'static': True,
                                                                'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                   'clientData': ['*'],
                                                                                   'func': [],
                                                                                   'panelName': ['const',
                                                                                                 '&']},
                                                                'types': {'clientData': 'void',
                                                                          'func': ('MMessage',
                                                                                   'MStringFunction'),
                                                                          'panelName': 'MString'}}],
                             'add3dViewRenderOverrideChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                                    'type': 'void'},
                                                                                     'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that contains the 3d view  oldOverride The name of the old override used to draw in the 3d view  newOverride The name of the new override used to draw in the 3d view  clientData User defined data passed to the callback function   ',
                                                                                              'type': ('MMessage',
                                                                                                       'MThreeStringFunction')},
                                                                                     'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                                   'type': 'MString'}},
                                                                         'args': [('panelName',
                                                                                   'MString',
                                                                                   'in'),
                                                                                  ('func',
                                                                                   ('MMessage',
                                                                                    'MThreeStringFunction'),
                                                                                   'in'),
                                                                                  ('clientData',
                                                                                   'void',
                                                                                   'in')],
                                                                         'defaults': {'clientData': None},
                                                                         'deprecated': False,
                                                                         'doc': '\r\nThis method registers a callback for when the render override for a particular 3d view changes.',
                                                                         'inArgs': ['panelName',
                                                                                    'func',
                                                                                    'clientData'],
                                                                         'outArgs': [],
                                                                         'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                        'qualifiers': [],
                                                                                        'type': 'MCallbackId'},
                                                                         'returnType': 'MCallbackId',
                                                                         'static': True,
                                                                         'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                            'clientData': ['*'],
                                                                                            'func': [],
                                                                                            'panelName': ['const',
                                                                                                          '&']},
                                                                         'types': {'clientData': 'void',
                                                                                   'func': ('MMessage',
                                                                                            'MThreeStringFunction'),
                                                                                   'panelName': 'MString'}}],
                             'add3dViewRendererChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                              'type': 'void'},
                                                                               'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that contains the 3d view  oldRenderer The name of the old renderer used to draw the 3d view  newRenderer The name of the new renderer used to draw the 3d view  clientData User defined data passed to the callback function   ',
                                                                                        'type': ('MMessage',
                                                                                                 'MThreeStringFunction')},
                                                                               'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                             'type': 'MString'}},
                                                                   'args': [('panelName',
                                                                             'MString',
                                                                             'in'),
                                                                            ('func',
                                                                             ('MMessage',
                                                                              'MThreeStringFunction'),
                                                                             'in'),
                                                                            ('clientData',
                                                                             'void',
                                                                             'in')],
                                                                   'defaults': {'clientData': None},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nThis method registers a callback for when the renderer for a particular 3d view changes.',
                                                                   'inArgs': ['panelName',
                                                                              'func',
                                                                              'clientData'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                                  'qualifiers': [],
                                                                                  'type': 'MCallbackId'},
                                                                   'returnType': 'MCallbackId',
                                                                   'static': True,
                                                                   'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                      'clientData': ['*'],
                                                                                      'func': [],
                                                                                      'panelName': ['const',
                                                                                                    '&']},
                                                                   'types': {'clientData': 'void',
                                                                             'func': ('MMessage',
                                                                                      'MThreeStringFunction'),
                                                                             'panelName': 'MString'}}],
                             'addCameraChangedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                      'type': 'void'},
                                                                       'func': {'doc': 'the callback function, which takes the following parameters:  panelName The name of the panel that had the camera change.  camera The current camera used by the panel.  clientData User defined data passed to the callback function   ',
                                                                                'type': ('MMessage',
                                                                                         'MStringNode')},
                                                                       'panelName': {'doc': 'Name of panel to which to attach the callback. ',
                                                                                     'type': 'MString'}},
                                                           'args': [('panelName',
                                                                     'MString',
                                                                     'in'),
                                                                    ('func',
                                                                     ('MMessage',
                                                                      'MStringNode'),
                                                                     'in'),
                                                                    ('clientData',
                                                                     'void',
                                                                     'in')],
                                                           'defaults': {'clientData': None},
                                                           'deprecated': False,
                                                           'doc': "\r\nThis method registers a callback for cameras being changed in 3d views. The callback is called when the camera changes for the given panel, not when attributes on the panel's camera change.",
                                                           'inArgs': ['panelName',
                                                                      'func',
                                                                      'clientData'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                          'qualifiers': [],
                                                                          'type': 'MCallbackId'},
                                                           'returnType': 'MCallbackId',
                                                           'static': True,
                                                           'typeQualifiers': {'ReturnStatus': ['*'],
                                                                              'clientData': ['*'],
                                                                              'func': [],
                                                                              'panelName': ['const',
                                                                                            '&']},
                                                           'types': {'clientData': 'void',
                                                                     'func': ('MMessage',
                                                                              'MStringNode'),
                                                                     'panelName': 'MString'}}],
                             'addUiDeletedCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                  'type': 'void'},
                                                                   'func': {'doc': 'the callback function, which takes the following parameters:  clientData User defined data passed to the callback function   ',
                                                                            'type': ('MMessage',
                                                                                     'MBasicFunction')},
                                                                   'uiName': {'doc': 'the name of the UI object to register the callback for ',
                                                                              'type': 'MString'}},
                                                       'args': [('uiName',
                                                                 'MString',
                                                                 'in'),
                                                                ('func',
                                                                 ('MMessage',
                                                                  'MBasicFunction'),
                                                                 'in'),
                                                                ('clientData',
                                                                 'void',
                                                                 'in')],
                                                       'defaults': {'clientData': None},
                                                       'deprecated': False,
                                                       'doc': '\r\nThis method registers a callback for UI deleted messages.',
                                                       'inArgs': ['uiName',
                                                                  'func',
                                                                  'clientData'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                      'qualifiers': [],
                                                                      'type': 'MCallbackId'},
                                                       'returnType': 'MCallbackId',
                                                       'static': True,
                                                       'typeQualifiers': {'ReturnStatus': ['*'],
                                                                          'clientData': ['*'],
                                                                          'func': [],
                                                                          'uiName': ['const',
                                                                                     '&']},
                                                       'types': {'clientData': 'void',
                                                                 'func': ('MMessage',
                                                                          'MBasicFunction'),
                                                                 'uiName': 'MString'}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                 'pymelEnums': {}},
  'MUint64Array': {'enums': {},
                   'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                   ('setLength', 'length')],
                   'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nNO SCRIPT SUPPORT. \n',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The value of the indicated element. ',
                                                               'qualifiers': [],
                                                               'type': 'MUint64'},
                                                'returnType': 'MUint64',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}},
                                               {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nNO SCRIPT SUPPORT. \n',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MUint64'},
                                                'returnType': 'MUint64',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                   'type': 'MUint64'}},
                                           'args': [('element',
                                                     'MUint64',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': []},
                                           'types': {'element': 'MUint64'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                'type': 'MUint64Array'}},
                                         'args': [('source',
                                                   'MUint64Array',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nCopy the contents of the source array to this array.',
                                         'inArgs': ['source'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'source': ['const',
                                                                       '&']},
                                         'types': {'source': 'MUint64Array'}}],
                               'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                              'type': 'MUint64__array'}},
                                        'args': [('array',
                                                  'MUint64__array',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nCopy the elements of the array into the given C++ array of MUint64s. No checking is done to ensure that the destination C++ array of MUint64s is large enough to hold all the elements of the instance.',
                                        'inArgs': [],
                                        'outArgs': ['array'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'array': []},
                                        'types': {'array': 'MUint64__array'}}],
                               'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                   'type': 'MUint64'},
                                                       'index': {'doc': 'the index of the element to set to the the new value',
                                                                 'type': 'uint'}},
                                           'args': [('element',
                                                     'MUint64',
                                                     'in'),
                                                    ('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element', 'index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': [],
                                                              'index': ['unsigned']},
                                           'types': {'element': 'MUint64',
                                                     'index': 'uint'}}],
                               'length': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nReturns the number of elements in the instance.',
                                           'inArgs': [],
                                           'inverse': ('setLength',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned']},
                                           'types': {'index': 'uint'}}],
                               'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'MUint64'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'MUint64',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\nSets the value of the indicated element to the indicated MUint64 value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': [],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'MUint64',
                                                  'index': 'uint'}}],
                               'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                     'type': 'uint'}},
                                              'args': [('length',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                              'inArgs': ['length'],
                                              'inverse': ('length', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'length': ['unsigned']},
                                              'types': {'length': 'uint'}}],
                               'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                  'type': 'uint'}},
                                                     'args': [('newIncrement',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                     'inArgs': ['newIncrement'],
                                                     'inverse': ('sizeIncrement',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'newIncrement': ['unsigned']},
                                                     'types': {'newIncrement': 'uint'}}],
                               'sizeIncrement': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                  'inArgs': [],
                                                  'inverse': ('setSizeIncrement',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'length': 'getLength',
                                    'sizeIncrement': 'getSizeIncrement'}},
  'MUintArray': {'enums': {},
                 'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                 ('setLength', 'length')],
                 'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The value of the indicated element. ',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned']},
                                              'types': {'index': 'uint'}},
                                             {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                    'type': 'uint'}},
                                              'args': [('index',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                              'inArgs': ['index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'A reference to the indicated element ',
                                                             'qualifiers': ['&'],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned']},
                                              'types': {'index': 'uint'}}],
                             'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                 'type': 'uint'}},
                                         'args': [('element',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                         'inArgs': ['element'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'element': ['unsigned']},
                                         'types': {'element': 'uint'}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nReturns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'clear': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                             'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                              'type': 'MUintArray'}},
                                       'args': [('source',
                                                 'MUintArray',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nCopy the contents of the source array to this array.',
                                       'inArgs': ['source'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'source': ['const',
                                                                     '&']},
                                       'types': {'source': 'MUintArray'}}],
                             'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                            'type': 'uint__array'}},
                                      'args': [('array',
                                                'uint__array',
                                                'out')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nCopy the elements of the array into the given C++ array of unsigned ints. No checking is done to ensure that the destination C++ array of ints is large enough to hold all the elements of the instance.',
                                      'inArgs': [],
                                      'outArgs': ['array'],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'array': ['unsigned']},
                                      'types': {'array': 'uint__array'}}],
                             'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                 'type': 'uint'},
                                                     'index': {'doc': 'the index of the element to set to the the new value',
                                                               'type': 'uint'}},
                                         'args': [('element',
                                                   'uint',
                                                   'in'),
                                                  ('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                         'inArgs': ['element', 'index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'element': ['unsigned'],
                                                            'index': ['unsigned']},
                                         'types': {'element': 'uint',
                                                   'index': 'uint'}}],
                             'length': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nReturns the number of elements in the instance.',
                                         'inArgs': [],
                                         'inverse': ('setLength', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The number of elements in the instance ',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                               'type': 'uint'}},
                                         'args': [('index',
                                                   'uint',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                         'inArgs': ['index'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'index': ['unsigned']},
                                         'types': {'index': 'uint'}}],
                             'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                              'type': 'uint'},
                                                  'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                            'type': 'uint'}},
                                      'args': [('element', 'uint', 'in'),
                                               ('index', 'uint', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nSets the value of the indicated element to the indicated value.',
                                      'inArgs': ['element', 'index'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'element': ['unsigned'],
                                                         'index': ['unsigned']},
                                      'types': {'element': 'uint',
                                                'index': 'uint'}}],
                             'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                   'type': 'uint'}},
                                            'args': [('length',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                            'inArgs': ['length'],
                                            'inverse': ('length', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'length': ['unsigned']},
                                            'types': {'length': 'uint'}}],
                             'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                'type': 'uint'}},
                                                   'args': [('newIncrement',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                   'inArgs': ['newIncrement'],
                                                   'inverse': ('sizeIncrement',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'newIncrement': ['unsigned']},
                                                   'types': {'newIncrement': 'uint'}}],
                             'sizeIncrement': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                'inArgs': [],
                                                'inverse': ('setSizeIncrement',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'int'},
                                                'returnType': 'int',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                 'pymelEnums': {},
                 'pymelMethods': {'length': 'getLength',
                                  'sizeIncrement': 'getSizeIncrement'}},
  'MUniformParameter': {'enums': {'DataSemantic': {'valueDocs': {'HWSEdgeLevel': '',
                                                                 'HWSFaceLevel': '',
                                                                 'HWSFrontCCW': '',
                                                                 'HWSHighlighting': '',
                                                                 'HWSInstancedDraw': '',
                                                                 'HWSObjectLevel': '',
                                                                 'HWSOccluder': '',
                                                                 'HWSPrimitiveBase': '',
                                                                 'HWSPrimitiveCountPerInstance': '',
                                                                 'HWSVertexLevel': '',
                                                                 'backgroundColor': '',
                                                                 'bump': '',
                                                                 'bumpTexture': '',
                                                                 'color': '',
                                                                 'colorTexture': '',
                                                                 'environment': '',
                                                                 'farClipPlane': '',
                                                                 'frameNumber': '',
                                                                 'kSemanticBackgroundColor': '',
                                                                 'kSemanticBump': '',
                                                                 'kSemanticBumpTexture': '',
                                                                 'kSemanticColor': '',
                                                                 'kSemanticColorTexture': '',
                                                                 'kSemanticEnvironment': '',
                                                                 'kSemanticFarClipPlane': '',
                                                                 'kSemanticFrameNumber': '',
                                                                 'kSemanticHWSEdgeLevel': '',
                                                                 'kSemanticHWSFaceLevel': '',
                                                                 'kSemanticHWSFrontCCW': '',
                                                                 'kSemanticHWSHighlighting': '',
                                                                 'kSemanticHWSInstancedDraw': '',
                                                                 'kSemanticHWSObjectLevel': '',
                                                                 'kSemanticHWSOccluder': '',
                                                                 'kSemanticHWSPrimitiveBase': '',
                                                                 'kSemanticHWSPrimitiveCountPerInstance': '',
                                                                 'kSemanticHWSVertexLevel': '',
                                                                 'kSemanticLocalViewer': '',
                                                                 'kSemanticNearClipPlane': '',
                                                                 'kSemanticNormal': '',
                                                                 'kSemanticNormalTexture': '',
                                                                 'kSemanticNormalizationTexture': '',
                                                                 'kSemanticObjectDir': '',
                                                                 'kSemanticObjectPos': '',
                                                                 'kSemanticOpaqueDepthTexture': '',
                                                                 'kSemanticProjectionDir': '',
                                                                 'kSemanticProjectionInverseMatrix': '',
                                                                 'kSemanticProjectionInverseTransposeMatrix': '',
                                                                 'kSemanticProjectionMatrix': '',
                                                                 'kSemanticProjectionPos': '',
                                                                 'kSemanticProjectionTransposeMatrix': '',
                                                                 'kSemanticTime': '',
                                                                 'kSemanticTranspDepthTexture': '',
                                                                 'kSemanticUnknown': '',
                                                                 'kSemanticViewDir': '',
                                                                 'kSemanticViewInverseMatrix': '',
                                                                 'kSemanticViewInverseTransposeMatrix': '',
                                                                 'kSemanticViewMatrix': '',
                                                                 'kSemanticViewPos': '',
                                                                 'kSemanticViewProjectionInverseMatrix': '',
                                                                 'kSemanticViewProjectionInverseTransposeMatrix': '',
                                                                 'kSemanticViewProjectionMatrix': '',
                                                                 'kSemanticViewProjectionTransposeMatrix': '',
                                                                 'kSemanticViewTransposeMatrix': '',
                                                                 'kSemanticViewportPixelSize': '',
                                                                 'kSemanticWorldDir': '',
                                                                 'kSemanticWorldInverseMatrix': '',
                                                                 'kSemanticWorldInverseTransposeMatrix': '',
                                                                 'kSemanticWorldMatrix': '',
                                                                 'kSemanticWorldPos': '',
                                                                 'kSemanticWorldTransposeMatrix': '',
                                                                 'kSemanticWorldViewInverseMatrix': '',
                                                                 'kSemanticWorldViewInverseTransposeMatrix': '',
                                                                 'kSemanticWorldViewMatrix': '',
                                                                 'kSemanticWorldViewProjectionInverseMatrix': '',
                                                                 'kSemanticWorldViewProjectionInverseTransposeMatrix': '',
                                                                 'kSemanticWorldViewProjectionMatrix': '',
                                                                 'kSemanticWorldViewProjectionTransposeMatrix': '',
                                                                 'kSemanticWorldViewTransposeMatrix': '',
                                                                 'localViewer': '',
                                                                 'nearClipPlane': '',
                                                                 'normal': '',
                                                                 'normalTexture': '',
                                                                 'normalizationTexture': '',
                                                                 'objectDir': '',
                                                                 'objectPos': '',
                                                                 'opaqueDepthTexture': '',
                                                                 'projectionDir': '',
                                                                 'projectionInverseMatrix': '',
                                                                 'projectionInverseTransposeMatrix': '',
                                                                 'projectionMatrix': '',
                                                                 'projectionPos': '',
                                                                 'projectionTransposeMatrix': '',
                                                                 'time': '',
                                                                 'transpDepthTexture': '',
                                                                 'unknown': '',
                                                                 'viewDir': '',
                                                                 'viewInverseMatrix': '',
                                                                 'viewInverseTransposeMatrix': '',
                                                                 'viewMatrix': '',
                                                                 'viewPos': '',
                                                                 'viewProjectionInverseMatrix': '',
                                                                 'viewProjectionInverseTransposeMatrix': '',
                                                                 'viewProjectionMatrix': '',
                                                                 'viewProjectionTransposeMatrix': '',
                                                                 'viewTransposeMatrix': '',
                                                                 'viewportPixelSize': '',
                                                                 'worldDir': '',
                                                                 'worldInverseMatrix': '',
                                                                 'worldInverseTransposeMatrix': '',
                                                                 'worldMatrix': '',
                                                                 'worldPos': '',
                                                                 'worldTransposeMatrix': '',
                                                                 'worldViewInverseMatrix': '',
                                                                 'worldViewInverseTransposeMatrix': '',
                                                                 'worldViewMatrix': '',
                                                                 'worldViewProjectionInverseMatrix': '',
                                                                 'worldViewProjectionInverseTransposeMatrix': '',
                                                                 'worldViewProjectionMatrix': '',
                                                                 'worldViewProjectionTransposeMatrix': '',
                                                                 'worldViewTransposeMatrix': ''},
                                                   'values': "Enum('DataSemantic', {'kSemanticUnknown': 0, 'kSemanticObjectDir': 1, 'kSemanticWorldDir': 2, 'kSemanticViewDir': 3, 'kSemanticProjectionDir': 4, 'kSemanticObjectPos': 5, 'kSemanticWorldPos': 6, 'kSemanticViewPos': 7, 'kSemanticProjectionPos': 8, 'kSemanticColor': 9, 'kSemanticNormal': 10, 'kSemanticBump': 11, 'kSemanticEnvironment': 12, 'kSemanticWorldMatrix': 13, 'kSemanticWorldInverseMatrix': 14, 'kSemanticWorldInverseTransposeMatrix': 15, 'kSemanticViewMatrix': 16, 'kSemanticViewInverseMatrix': 17, 'kSemanticViewInverseTransposeMatrix': 18, 'kSemanticProjectionMatrix': 19, 'kSemanticProjectionInverseMatrix': 20, 'kSemanticProjectionInverseTransposeMatrix': 21, 'kSemanticWorldViewMatrix': 22, 'kSemanticWorldViewInverseMatrix': 23, 'kSemanticWorldViewInverseTransposeMatrix': 24, 'kSemanticWorldViewProjectionMatrix': 25, 'kSemanticWorldViewProjectionInverseMatrix': 26, 'kSemanticWorldViewProjectionInverseTransposeMatrix': 27, 'kSemanticColorTexture': 28, 'kSemanticNormalTexture': 29, 'kSemanticBumpTexture': 30, 'kSemanticNormalizationTexture': 31, 'kSemanticTranspDepthTexture': 32, 'kSemanticOpaqueDepthTexture': 33, 'kSemanticTime': 34, 'kSemanticWorldTransposeMatrix': 35, 'kSemanticViewTransposeMatrix': 36, 'kSemanticProjectionTransposeMatrix': 37, 'kSemanticWorldViewTransposeMatrix': 38, 'kSemanticWorldViewProjectionTransposeMatrix': 39, 'kSemanticViewProjectionMatrix': 40, 'kSemanticViewProjectionInverseMatrix': 41, 'kSemanticViewProjectionTransposeMatrix': 42, 'kSemanticViewProjectionInverseTransposeMatrix': 43, 'kSemanticLocalViewer': 44, 'kSemanticViewportPixelSize': 45, 'kSemanticBackgroundColor': 46, 'kSemanticFrameNumber': 47, 'kSemanticNearClipPlane': 48, 'kSemanticFarClipPlane': 49, 'kSemanticHWSPrimitiveBase': 50, 'kSemanticHWSPrimitiveCountPerInstance': 51, 'kSemanticHWSObjectLevel': 52, 'kSemanticHWSFaceLevel': 53, 'kSemanticHWSEdgeLevel': 54, 'kSemanticHWSVertexLevel': 55, 'kSemanticHWSOccluder': 56, 'kSemanticHWSFrontCCW': 57, 'kSemanticHWSInstancedDraw': 58, 'kSemanticHWSHighlighting': 59})"},
                                  'DataType': {'valueDocs': {'kType1DTexture': '',
                                                             'kType2DTexture': '',
                                                             'kType3DTexture': '',
                                                             'kTypeBool': '',
                                                             'kTypeCubeTexture': '',
                                                             'kTypeEnum': '',
                                                             'kTypeEnvTexture': '',
                                                             'kTypeFloat': '',
                                                             'kTypeInt': '',
                                                             'kTypeString': '',
                                                             'kTypeUnknown': '',
                                                             'type1DTexture': '',
                                                             'type2DTexture': '',
                                                             'type3DTexture': '',
                                                             'typeBool': '',
                                                             'typeCubeTexture': '',
                                                             'typeEnum': '',
                                                             'typeEnvTexture': '',
                                                             'typeFloat': '',
                                                             'typeInt': '',
                                                             'typeString': '',
                                                             'typeUnknown': ''},
                                               'values': "Enum('DataType', {'kTypeUnknown': 0, 'kTypeBool': 1, 'kTypeInt': 2, 'kTypeFloat': 3, 'kType1DTexture': 4, 'kType2DTexture': 5, 'kType3DTexture': 6, 'kTypeCubeTexture': 7, 'kTypeEnvTexture': 8, 'kTypeString': 9, 'kTypeEnum': 10})"}},
                        'invertibles': [('setAsBool', 'getAsBool'),
                                        ('setAsInt', 'getAsInt'),
                                        ('setAsString', 'getAsString'),
                                        ('setKeyable', 'keyable'),
                                        ('setAsFloat', 'getAsFloat'),
                                        ('setAsFloatArray',
                                         'getAsFloatArray')],
                        'methods': {'UIHidden': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGets the hidden state of this parameter.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'getAsBool': [{'argInfo': {'iterator': {'doc': 'the current shape being rendered.',
                                                                            'type': 'MGeometryList'}},
                                                   'args': [('iterator',
                                                             'MGeometryList',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the value of this uniform parameter as a boolean value. Because some parameters can be shape-dependent, the method requires access to the current geometry item being rendered.',
                                                   'inArgs': ['iterator'],
                                                   'inverse': ('setAsBool',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The current boolean value of this uniform parameter. ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'iterator': ['const',
                                                                                   '&']},
                                                   'types': {'iterator': 'MGeometryList'}},
                                                  {'argInfo': {'context': {'doc': 'Draw context being used for render.',
                                                                           'type': ('MHWRender',
                                                                                    'MDrawContext')}},
                                                   'args': [('context',
                                                             ('MHWRender',
                                                              'MDrawContext'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the value of this uniform parameter as a boolean value. Because some parameters can be shape-dependent, the method requires access to the current context being rendered.',
                                                   'inArgs': ['context'],
                                                   'inverse': ('setAsBool',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The current boolean value of this uniform parameter. ',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {'context': ['const',
                                                                                  '&']},
                                                   'types': {'context': ('MHWRender',
                                                                         'MDrawContext')}}],
                                    'getAsFloat': [{'argInfo': {'iterator': {'doc': 'the current shape being rendered.',
                                                                             'type': 'MGeometryList'}},
                                                    'args': [('iterator',
                                                              'MGeometryList',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the value of this uniform parameter as a float. Because some parameters can be shape-dependent, the method requires access to the current geometry item being rendered.',
                                                    'inArgs': ['iterator'],
                                                    'inverse': ('setAsFloat',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The current float value of this uniform parameter. ',
                                                                   'qualifiers': [],
                                                                   'type': 'float'},
                                                    'returnType': 'float',
                                                    'static': False,
                                                    'typeQualifiers': {'iterator': ['const',
                                                                                    '&']},
                                                    'types': {'iterator': 'MGeometryList'}},
                                                   {'argInfo': {'context': {'doc': 'Draw context being used for render.',
                                                                            'type': ('MHWRender',
                                                                                     'MDrawContext')}},
                                                    'args': [('context',
                                                              ('MHWRender',
                                                               'MDrawContext'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the value of this uniform parameter as a float. Because some parameters can be shape-dependent, the method requires access to the current context being rendered.',
                                                    'inArgs': ['context'],
                                                    'inverse': ('setAsFloat',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The current float value of this uniform parameter. ',
                                                                   'qualifiers': [],
                                                                   'type': 'float'},
                                                    'returnType': 'float',
                                                    'static': False,
                                                    'typeQualifiers': {'context': ['const',
                                                                                   '&']},
                                                    'types': {'context': ('MHWRender',
                                                                          'MDrawContext')}}],
                                    'getAsFloatArray': [{'argInfo': {'iterator': {'doc': 'the current shape being rendered.',
                                                                                  'type': 'MGeometryList'}},
                                                         'args': [('iterator',
                                                                   'MGeometryList',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGet the value of this uniform parameter as one or more floating point values. Because some parameters can be shape-dependent, the method requires access to the current geometry item being rendered.',
                                                         'inArgs': ['iterator'],
                                                         'inverse': ('setAsFloatArray',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A pointer to an array of floating point values for this uniform parameter. ',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'float'},
                                                         'returnType': 'float',
                                                         'static': False,
                                                         'typeQualifiers': {'iterator': ['const',
                                                                                         '&']},
                                                         'types': {'iterator': 'MGeometryList'}},
                                                        {'argInfo': {'context': {'doc': 'Draw context being used for render.',
                                                                                 'type': ('MHWRender',
                                                                                          'MDrawContext')}},
                                                         'args': [('context',
                                                                   ('MHWRender',
                                                                    'MDrawContext'),
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nGet the value of this uniform parameter as one or more floating point values. Because some parameters can be shape-dependent, the method requires access to the current context being rendered.',
                                                         'inArgs': ['context'],
                                                         'inverse': ('setAsFloatArray',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A pointer to an array of floating point values for this uniform parameter. ',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'float'},
                                                         'returnType': 'float',
                                                         'static': False,
                                                         'typeQualifiers': {'context': ['const',
                                                                                        '&']},
                                                         'types': {'context': ('MHWRender',
                                                                               'MDrawContext')}}],
                                    'getAsInt': [{'argInfo': {'iterator': {'doc': 'the current shape being rendered.',
                                                                           'type': 'MGeometryList'}},
                                                  'args': [('iterator',
                                                            'MGeometryList',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the value of this uniform parameter as an integer. Because some parameters can be shape-dependent, the method requires access to the current geometry item being rendered.',
                                                  'inArgs': ['iterator'],
                                                  'inverse': ('setAsInt',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The current integer value of this uniform parameter. ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'iterator': ['const',
                                                                                  '&']},
                                                  'types': {'iterator': 'MGeometryList'}},
                                                 {'argInfo': {'context': {'doc': 'Draw context being used for render.',
                                                                          'type': ('MHWRender',
                                                                                   'MDrawContext')}},
                                                  'args': [('context',
                                                            ('MHWRender',
                                                             'MDrawContext'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the value of this uniform parameter as an integer. Because some parameters can be shape-dependent, the method requires access to the current context being rendered.',
                                                  'inArgs': ['context'],
                                                  'inverse': ('setAsInt',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The current integer value of this uniform parameter. ',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {'context': ['const',
                                                                                 '&']},
                                                  'types': {'context': ('MHWRender',
                                                                        'MDrawContext')}}],
                                    'getAsString': [{'argInfo': {'iterator': {'doc': 'the current shape being rendered.',
                                                                              'type': 'MGeometryList'}},
                                                     'args': [('iterator',
                                                               'MGeometryList',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the value of this uniform parameter as a string. Because some parameters can be shape-dependent, the method requires access to the current geometry item being rendered.',
                                                     'inArgs': ['iterator'],
                                                     'inverse': ('setAsString',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The current string value of this uniform parameter. ',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': False,
                                                     'typeQualifiers': {'iterator': ['const',
                                                                                     '&']},
                                                     'types': {'iterator': 'MGeometryList'}},
                                                    {'argInfo': {'context': {'doc': 'Draw context being used for render.',
                                                                             'type': ('MHWRender',
                                                                                      'MDrawContext')}},
                                                     'args': [('context',
                                                               ('MHWRender',
                                                                'MDrawContext'),
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the value of this uniform parameter as a string. Because some parameters can be shape-dependent, the method requires access to the current context being rendered.',
                                                     'inArgs': ['context'],
                                                     'inverse': ('setAsString',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The current string value of this uniform parameter. ',
                                                                    'qualifiers': [],
                                                                    'type': 'MString'},
                                                     'returnType': 'MString',
                                                     'static': False,
                                                     'typeQualifiers': {'context': ['const',
                                                                                    '&']},
                                                     'types': {'context': ('MHWRender',
                                                                           'MDrawContext')}}],
                                    'getPlug': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the plug managed by this parameter. \r\n',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'MPlug'},
                                                 'returnType': 'MPlug',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'getSource': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the source plug connected to this parameter. Other than textures, this will typically be a NULL plug. \r\n  Reprocessed example  \n Examples: \n \n   \n hlslShader.cpp . \n \n',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MPlug'},
                                                   'returnType': 'MPlug',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'hasChanged': [{'argInfo': {'iterator': {'doc': 'the current shape being rendered.',
                                                                             'type': 'MGeometryList'}},
                                                    'args': [('iterator',
                                                              'MGeometryList',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nHas the value of this parameter changed since the last time it was accessed? This allows your shader to minimise state changes by only updating modified parameters.',
                                                    'inArgs': ['iterator'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': "true if this parameter's value has changed since the last time its value was accessed. false otherwise. ",
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'iterator': ['const',
                                                                                    '&']},
                                                    'types': {'iterator': 'MGeometryList'}},
                                                   {'argInfo': {'context': {'doc': 'Draw context being used for render.',
                                                                            'type': ('MHWRender',
                                                                                     'MDrawContext')}},
                                                    'args': [('context',
                                                              ('MHWRender',
                                                               'MDrawContext'),
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nHas the value of this parameter changed since the last time it was accessed? This allows your shader to minimise state changes by only updating modified parameters.',
                                                    'inArgs': ['context'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': "true if this parameter's value has changed since the last time its value was accessed. false otherwise. ",
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {'context': ['const',
                                                                                   '&']},
                                                    'types': {'context': ('MHWRender',
                                                                          'MDrawContext')}}],
                                    'isATexture': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nTest if this parameter stores a texture.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'true if this parameter represents a texture, false otherwise. ',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'keyable': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGets the keyable state of this parameter.',
                                                 'inArgs': [],
                                                 'inverse': ('setKeyable',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'name': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the name of this parameter',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of this parameter ',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'numColumns': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the number of columns in this parameter',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'numElements': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the number of elements in this parameter (including rows and columns)',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The number of elements in this parameter ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'numRows': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nGet the number of rows in this parameter',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                    'semantic': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the semantic of this parameter',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': ('MUniformParameter',
                                                                          'DataSemantic')},
                                                  'returnType': ('MUniformParameter',
                                                                 'DataSemantic'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'setAsBool': [{'argInfo': {'value': {'doc': 'the new value for this parameter. ',
                                                                         'type': 'bool'}},
                                                   'args': [('value',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the value of this uniform parameter as a boolean value. Note that it is not possible to set shape-dependent parameters.',
                                                   'inArgs': ['value'],
                                                   'inverse': ('getAsBool',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'value': []},
                                                   'types': {'value': 'bool'}}],
                                    'setAsFloat': [{'argInfo': {'value': {'doc': 'the new float value for this parameter. ',
                                                                          'type': 'float'}},
                                                    'args': [('value',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSet the value of this uniform parameter as a float. Note that it is not possible to set shape-dependent parameters.',
                                                    'inArgs': ['value'],
                                                    'inverse': ('getAsFloat',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'value': []},
                                                    'types': {'value': 'float'}}],
                                    'setAsFloatArray': [{'argInfo': {'maxElements': {'doc': 'the maximum number of elements in the value array. ',
                                                                                     'type': 'uint'},
                                                                     'value': {'doc': 'a pointer an array of floats holding the new floating point value(s) for this parameter. ',
                                                                               'type': 'float'}},
                                                         'args': [('value',
                                                                   'float',
                                                                   'in'),
                                                                  ('maxElements',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSet the value of this uniform parameter as one or more floating point values. Note that it is not possible to set shape-specific parameters.',
                                                         'inArgs': ['value',
                                                                    'maxElements'],
                                                         'inverse': ('getAsFloatArray',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'maxElements': ['unsigned'],
                                                                            'value': ['const',
                                                                                      '*']},
                                                         'types': {'maxElements': 'uint',
                                                                   'value': 'float'}}],
                                    'setAsInt': [{'argInfo': {'value': {'doc': 'the new value for this parameter. ',
                                                                        'type': 'int'}},
                                                  'args': [('value',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSet the value of this uniform parameter as an integer value. Note that it is not possible to set shape-dependent parameters.',
                                                  'inArgs': ['value'],
                                                  'inverse': ('getAsInt',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'value': []},
                                                  'types': {'value': 'int'}}],
                                    'setAsString': [{'argInfo': {'value': {'doc': 'the new string value for this parameter. ',
                                                                           'type': 'MString'}},
                                                     'args': [('value',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the value of this uniform parameter as a string. Note that it is not possible to set shape-dependent parameters.',
                                                     'inArgs': ['value'],
                                                     'inverse': ('getAsString',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'value': ['const',
                                                                                  '&']},
                                                     'types': {'value': 'MString'}}],
                                    'setDirty': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nMark the data for this parameter as dirty. This will force the parameter to report that it has been changed the next time it is accessed. This allows external events (e.g. device lost, texture management, etc) to force a shader to re-set parameters tied to externally managed resources. \r\n  Reprocessed example  \n Examples: \n \n   \n hlslShader.cpp . \n \n',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'setEnumFieldNames': [{'argInfo': {'fieldNames': {'doc': 'A string of colon ":" delimited field names which can specify an index value separated by an equal sign "=". The indexing starts at zero and the index value of an item when it is not explicitely specified is the index of the previous item (if any) incremented by one. Example: "Shaded:Wireframe=8:Bounding Box" defines 3 values with index 0, 8, and 9. ',
                                                                                      'type': 'MString'}},
                                                           'args': [('fieldNames',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nSets the field names of an enum attribute. The format of the string is the same as returned by the MEL command `attributeQuery -listEnum`.',
                                                           'inArgs': ['fieldNames'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'fieldNames': ['const',
                                                                                             '&']},
                                                           'types': {'fieldNames': 'MString'}}],
                                    'setKeyable': [{'argInfo': {'keyable': {'doc': 'True if the attribute should be keyable ',
                                                                            'type': 'bool'}},
                                                    'args': [('keyable',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets the keyable state of this parameter.',
                                                    'inArgs': ['keyable'],
                                                    'inverse': ('keyable',
                                                                True),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'keyable': []},
                                                    'types': {'keyable': 'bool'}}],
                                    'setRangeMax': [{'argInfo': {'rangeMax': {'doc': 'The upper bound of the range. ',
                                                                              'type': 'double'}},
                                                     'args': [('rangeMax',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the hard range upper bound for a numeric uniform parameter.',
                                                     'inArgs': ['rangeMax'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'rangeMax': []},
                                                     'types': {'rangeMax': 'double'}}],
                                    'setRangeMin': [{'argInfo': {'rangeMin': {'doc': 'The lower bound of the range. ',
                                                                              'type': 'double'}},
                                                     'args': [('rangeMin',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the hard range lower bound for a numeric uniform parameter.',
                                                     'inArgs': ['rangeMin'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'rangeMin': []},
                                                     'types': {'rangeMin': 'double'}}],
                                    'setSoftRangeMax': [{'argInfo': {'softRangeMax': {'doc': 'The upper bound of the slider. ',
                                                                                      'type': 'double'}},
                                                         'args': [('softRangeMax',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the soft range upper bound for a numeric uniform parameter.',
                                                         'inArgs': ['softRangeMax'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'softRangeMax': []},
                                                         'types': {'softRangeMax': 'double'}}],
                                    'setSoftRangeMin': [{'argInfo': {'softRangeMin': {'doc': 'The lower bound of the slider. ',
                                                                                      'type': 'double'}},
                                                         'args': [('softRangeMin',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': '\r\nSets the soft range lower bound for a numeric uniform parameter.',
                                                         'inArgs': ['softRangeMin'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'softRangeMin': []},
                                                         'types': {'softRangeMin': 'double'}}],
                                    'setUIHidden': [{'argInfo': {'hiddenState': {'doc': 'True will hide the corresponding attribute in the attribute editor. ',
                                                                                 'type': 'bool'}},
                                                     'args': [('hiddenState',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets the hidden state of this parameter.',
                                                     'inArgs': ['hiddenState'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'hiddenState': []},
                                                     'types': {'hiddenState': 'bool'}}],
                                    'setUINiceName': [{'argInfo': {'name': {'doc': 'The name that will be displayed in the Attribute Editor ',
                                                                            'type': 'MString'}},
                                                       'args': [('name',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSets the UI Nice Name for the attribute',
                                                       'inArgs': ['name'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'name': ['const',
                                                                                   '&']},
                                                       'types': {'name': 'MString'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the type of this parameter',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The type of this parameter ',
                                                             'qualifiers': [],
                                                             'type': ('MUniformParameter',
                                                                      'DataType')},
                                              'returnType': ('MUniformParameter',
                                                             'DataType'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'userData': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the user data for this parameter. User data can be used to store plugin specific information that you want to associate with this parameter. Typically this will be used to store a handle to the effect parameter.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': ['*'],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                        'pymelEnums': {'DataSemantic': "Enum('DataSemantic', [('unknown', 0), ('kSemanticUnknown', 0), ('objectDir', 1), ('kSemanticObjectDir', 1), ('worldDir', 2), ('kSemanticWorldDir', 2), ('viewDir', 3), ('kSemanticViewDir', 3), ('projectionDir', 4), ('kSemanticProjectionDir', 4), ('objectPos', 5), ('kSemanticObjectPos', 5), ('worldPos', 6), ('kSemanticWorldPos', 6), ('viewPos', 7), ('kSemanticViewPos', 7), ('projectionPos', 8), ('kSemanticProjectionPos', 8), ('color', 9), ('kSemanticColor', 9), ('normal', 10), ('kSemanticNormal', 10), ('bump', 11), ('kSemanticBump', 11), ('environment', 12), ('kSemanticEnvironment', 12), ('worldMatrix', 13), ('kSemanticWorldMatrix', 13), ('worldInverseMatrix', 14), ('kSemanticWorldInverseMatrix', 14), ('worldInverseTransposeMatrix', 15), ('kSemanticWorldInverseTransposeMatrix', 15), ('viewMatrix', 16), ('kSemanticViewMatrix', 16), ('viewInverseMatrix', 17), ('kSemanticViewInverseMatrix', 17), ('viewInverseTransposeMatrix', 18), ('kSemanticViewInverseTransposeMatrix', 18), ('projectionMatrix', 19), ('kSemanticProjectionMatrix', 19), ('projectionInverseMatrix', 20), ('kSemanticProjectionInverseMatrix', 20), ('projectionInverseTransposeMatrix', 21), ('kSemanticProjectionInverseTransposeMatrix', 21), ('worldViewMatrix', 22), ('kSemanticWorldViewMatrix', 22), ('worldViewInverseMatrix', 23), ('kSemanticWorldViewInverseMatrix', 23), ('worldViewInverseTransposeMatrix', 24), ('kSemanticWorldViewInverseTransposeMatrix', 24), ('worldViewProjectionMatrix', 25), ('kSemanticWorldViewProjectionMatrix', 25), ('worldViewProjectionInverseMatrix', 26), ('kSemanticWorldViewProjectionInverseMatrix', 26), ('worldViewProjectionInverseTransposeMatrix', 27), ('kSemanticWorldViewProjectionInverseTransposeMatrix', 27), ('colorTexture', 28), ('kSemanticColorTexture', 28), ('normalTexture', 29), ('kSemanticNormalTexture', 29), ('bumpTexture', 30), ('kSemanticBumpTexture', 30), ('normalizationTexture', 31), ('kSemanticNormalizationTexture', 31), ('transpDepthTexture', 32), ('kSemanticTranspDepthTexture', 32), ('opaqueDepthTexture', 33), ('kSemanticOpaqueDepthTexture', 33), ('time', 34), ('kSemanticTime', 34), ('worldTransposeMatrix', 35), ('kSemanticWorldTransposeMatrix', 35), ('viewTransposeMatrix', 36), ('kSemanticViewTransposeMatrix', 36), ('projectionTransposeMatrix', 37), ('kSemanticProjectionTransposeMatrix', 37), ('worldViewTransposeMatrix', 38), ('kSemanticWorldViewTransposeMatrix', 38), ('worldViewProjectionTransposeMatrix', 39), ('kSemanticWorldViewProjectionTransposeMatrix', 39), ('viewProjectionMatrix', 40), ('kSemanticViewProjectionMatrix', 40), ('viewProjectionInverseMatrix', 41), ('kSemanticViewProjectionInverseMatrix', 41), ('viewProjectionTransposeMatrix', 42), ('kSemanticViewProjectionTransposeMatrix', 42), ('viewProjectionInverseTransposeMatrix', 43), ('kSemanticViewProjectionInverseTransposeMatrix', 43), ('localViewer', 44), ('kSemanticLocalViewer', 44), ('viewportPixelSize', 45), ('kSemanticViewportPixelSize', 45), ('backgroundColor', 46), ('kSemanticBackgroundColor', 46), ('frameNumber', 47), ('kSemanticFrameNumber', 47), ('nearClipPlane', 48), ('kSemanticNearClipPlane', 48), ('farClipPlane', 49), ('kSemanticFarClipPlane', 49), ('HWSPrimitiveBase', 50), ('kSemanticHWSPrimitiveBase', 50), ('HWSPrimitiveCountPerInstance', 51), ('kSemanticHWSPrimitiveCountPerInstance', 51), ('HWSObjectLevel', 52), ('kSemanticHWSObjectLevel', 52), ('HWSFaceLevel', 53), ('kSemanticHWSFaceLevel', 53), ('HWSEdgeLevel', 54), ('kSemanticHWSEdgeLevel', 54), ('HWSVertexLevel', 55), ('kSemanticHWSVertexLevel', 55), ('HWSOccluder', 56), ('kSemanticHWSOccluder', 56), ('HWSFrontCCW', 57), ('kSemanticHWSFrontCCW', 57), ('HWSInstancedDraw', 58), ('kSemanticHWSInstancedDraw', 58), ('HWSHighlighting', 59), ('kSemanticHWSHighlighting', 59)], multiKeys=True)",
                                       'DataType': "Enum('DataType', [('typeUnknown', 0), ('kTypeUnknown', 0), ('typeBool', 1), ('kTypeBool', 1), ('typeInt', 2), ('kTypeInt', 2), ('typeFloat', 3), ('kTypeFloat', 3), ('type1DTexture', 4), ('kType1DTexture', 4), ('type2DTexture', 5), ('kType2DTexture', 5), ('type3DTexture', 6), ('kType3DTexture', 6), ('typeCubeTexture', 7), ('kTypeCubeTexture', 7), ('typeEnvTexture', 8), ('kTypeEnvTexture', 8), ('typeString', 9), ('kTypeString', 9), ('typeEnum', 10), ('kTypeEnum', 10)], multiKeys=True)"},
                        'pymelMethods': {'keyable': 'getKeyable'}},
  'MUniformParameterList': {'enums': {},
                            'invertibles': [('setElement', 'getElement'),
                                            ('setLength', 'length')],
                            'methods': {'append': [{'argInfo': {'element': {'doc': 'The new parameter to append ',
                                                                            'type': 'MUniformParameter'}},
                                                    'args': [('element',
                                                              'MUniformParameter',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nAppend a new parameter to this end of this list.',
                                                    'inArgs': ['element'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'element': ['const',
                                                                                   '&']},
                                                    'types': {'element': 'MUniformParameter'}}],
                                        'getElement': [{'argInfo': {'n': {'doc': 'the index of the element to return',
                                                                          'type': 'int'}},
                                                        'args': [('n',
                                                                  'int',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet the nth parameter in this list.',
                                                        'inArgs': ['n'],
                                                        'inverse': ('setElement',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The nth parameter in the list ',
                                                                       'qualifiers': [],
                                                                       'type': 'MUniformParameter'},
                                                        'returnType': 'MUniformParameter',
                                                        'static': False,
                                                        'typeQualifiers': {'n': []},
                                                        'types': {'n': 'int'}}],
                                        'length': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the number of parameters in this list.',
                                                    'inArgs': [],
                                                    'inverse': ('setLength',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                        'setElement': [{'argInfo': {'n': {'doc': 'the index of the element to return ',
                                                                          'type': 'int'},
                                                                    'p': {'doc': 'the requested parameter',
                                                                          'type': 'MUniformParameter'}},
                                                        'args': [('n',
                                                                  'int',
                                                                  'in'),
                                                                 ('p',
                                                                  'MUniformParameter',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet the nth parameter in this list.',
                                                        'inArgs': ['n'],
                                                        'inverse': ('getElement',
                                                                    True),
                                                        'outArgs': ['p'],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'n': [],
                                                                           'p': ['const',
                                                                                 '&']},
                                                        'types': {'n': 'int',
                                                                  'p': 'MUniformParameter'}}],
                                        'setLength': [{'argInfo': {'n': {'doc': 'The number of parameters in this list. ',
                                                                         'type': 'int'}},
                                                       'args': [('n',
                                                                 'int',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet the number of parameters in this list. If this is greater than the current number of parameters in the list, the caller is responsible for setting the new parameters to valid values using setElement.',
                                                       'inArgs': ['n'],
                                                       'inverse': ('length',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'n': []},
                                                       'types': {'n': 'int'}}]},
                            'pymelEnums': {},
                            'pymelMethods': {'length': 'getLength'}},
  'MUserData': {'enums': {},
                'invertibles': [('setDeleteAfterUse', 'deleteAfterUse')],
                'methods': {'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'deleteAfterUse': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturns whether or not this user data should be deleted immediately after use instead of being maintained until the internal owning object is deleted.',
                                                'inArgs': [],
                                                'inverse': ('setDeleteAfterUse',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                            'setDeleteAfterUse': [{'argInfo': {'shouldDelete': {'doc': 'If true this user data will be deleted after use ',
                                                                                'type': 'bool'}},
                                                   'args': [('shouldDelete',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets whether or not this user data should be deleted immediately after use instead of being maintained until the internal owning object is deleted.',
                                                   'inArgs': ['shouldDelete'],
                                                   'inverse': ('deleteAfterUse',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'shouldDelete': []},
                                                   'types': {'shouldDelete': 'bool'}}]},
                'pymelEnums': {},
                'pymelMethods': {'deleteAfterUse': 'getDeleteAfterUse'}},
  'MUserEventMessage': {'enums': {},
                        'methods': {'addUserEventCallback': [{'argInfo': {'clientData': {'doc': 'User defined data that will be passed to the callback function ',
                                                                                         'type': 'void'},
                                                                          'eventName': {'doc': 'the event name to register the callback for ',
                                                                                        'type': 'MString'},
                                                                          'func': {'doc': 'the callback function',
                                                                                   'type': ('MMessage',
                                                                                            'MBasicFunction')}},
                                                              'args': [('eventName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('func',
                                                                        ('MMessage',
                                                                         'MBasicFunction'),
                                                                        'in'),
                                                                       ('clientData',
                                                                        'void',
                                                                        'in')],
                                                              'defaults': {'clientData': None},
                                                              'deprecated': False,
                                                              'doc': '\r\nThis method registers a callback for user-defined messages.',
                                                              'inArgs': ['eventName',
                                                                         'func',
                                                                         'clientData'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'Identifier used for removing the callback.',
                                                                             'qualifiers': [],
                                                                             'type': 'MCallbackId'},
                                                              'returnType': 'MCallbackId',
                                                              'static': True,
                                                              'typeQualifiers': {'ReturnStatus': ['*'],
                                                                                 'clientData': ['*'],
                                                                                 'eventName': ['const',
                                                                                               '&'],
                                                                                 'func': []},
                                                              'types': {'clientData': 'void',
                                                                        'eventName': 'MString',
                                                                        'func': ('MMessage',
                                                                                 'MBasicFunction')}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nReturns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'deregisterUserEvent': [{'argInfo': {'eventName': {'doc': 'the event name',
                                                                                       'type': 'MString'}},
                                                             'args': [('eventName',
                                                                       'MString',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nRemoves the event type with the given event name. If callbacks have been registered with this event type, they will become invalid after a successful call to this method.',
                                                             'inArgs': ['eventName'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': True,
                                                             'typeQualifiers': {'eventName': ['const',
                                                                                              '&']},
                                                             'types': {'eventName': 'MString'}}],
                                    'isUserEvent': [{'argInfo': {'eventName': {'doc': 'the event name',
                                                                               'type': 'MString'}},
                                                     'args': [('eventName',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nChecks if an event type exists with the given event name.',
                                                     'inArgs': ['eventName'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': ' true Event type exists  false Event type does not exist   ',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': True,
                                                     'typeQualifiers': {'eventName': ['const',
                                                                                      '&']},
                                                     'types': {'eventName': 'MString'}}],
                                    'postUserEvent': [{'argInfo': {'clientData': {'doc': 'caller-defined data to be passed to the callback',
                                                                                  'type': 'void'},
                                                                   'eventName': {'doc': 'the event name ',
                                                                                 'type': 'MString'}},
                                                       'args': [('eventName',
                                                                 'MString',
                                                                 'in'),
                                                                ('clientData',
                                                                 'void',
                                                                 'in')],
                                                       'defaults': {'clientData': None},
                                                       'deprecated': False,
                                                       'doc': '\r\nNotifies all callbacks attached to the given event type of the occurence of the event.',
                                                       'inArgs': ['eventName',
                                                                  'clientData'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': True,
                                                       'typeQualifiers': {'clientData': ['*'],
                                                                          'eventName': ['const',
                                                                                        '&']},
                                                       'types': {'clientData': 'void',
                                                                 'eventName': 'MString'}}],
                                    'registerUserEvent': [{'argInfo': {'eventName': {'doc': 'the name of the new event to register. Any non-empty string may be used as an event name.',
                                                                                     'type': 'MString'}},
                                                           'args': [('eventName',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nAdds a new event type with the given string identifier. The string identifier can then be used in all other  MUserEventMessage  methods to operate on the new event type.',
                                                           'inArgs': ['eventName'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': True,
                                                           'typeQualifiers': {'eventName': ['const',
                                                                                            '&']},
                                                           'types': {'eventName': 'MString'}}]},
                        'pymelEnums': {}},
  'MUuid': {'enums': {},
            'methods': {'MString': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\nCast to string.',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': ('MUuid',
                                                             'operator')},
                                     'returnType': ('MUuid', 'operator'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                        '__eq__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                        'type': 'MUuid'}},
                                    'args': [('rhs', 'MUuid', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nEquality operator. Compares two  MUuid  objects to see if they contain the same value.',
                                    'inArgs': ['rhs'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'true if the two objects are equivalent, false otherwise. ',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'rhs': ['const',
                                                               '&']},
                                    'types': {'rhs': 'MUuid'}}],
                        '__ne__': [{'argInfo': {'rhs': {'doc': 'Right operand. ',
                                                        'type': 'MUuid'}},
                                    'args': [('rhs', 'MUuid', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nInequality operator. Compares two  MUuid  objects to see if they differ.',
                                    'inArgs': ['rhs'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'true if the two objects are different, false otherwise. ',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'rhs': ['const',
                                                               '&']},
                                    'types': {'rhs': 'MUuid'}}],
                        'asString': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nGets the UUID as a string.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'MString'},
                                      'returnType': 'MString',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                        'className': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nReturns the name of this class.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': ['*'],
                                                      'type': 'char'},
                                       'returnType': 'char',
                                       'static': True,
                                       'typeQualifiers': {},
                                       'types': {}}],
                        'copy': [{'argInfo': {'rhs': {'doc': 'Existing MUuid object to copy. ',
                                                      'type': 'MUuid'}},
                                  'args': [('rhs', 'MUuid', 'in')],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '\nCopy method. Assigns the value of one  MUuid  to another.',
                                  'inArgs': ['rhs'],
                                  'outArgs': [],
                                  'returnInfo': {'doc': '',
                                                 'qualifiers': [],
                                                 'type': None},
                                  'returnType': None,
                                  'static': False,
                                  'typeQualifiers': {'rhs': ['const',
                                                             '&']},
                                  'types': {'rhs': 'MUuid'}}],
                        'generate': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nGenerates a new random UUID and stores it in this class instance.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                        'get': [{'argInfo': {'dest': {'doc': 'The array to populate with the UUID value.',
                                                      'type': 'uchar'}},
                                 'args': [('dest', 'uchar', 'out')],
                                 'defaults': {},
                                 'deprecated': False,
                                 'doc': '\nGets the UUID as an array of sixteen bytes.',
                                 'inArgs': [],
                                 'outArgs': ['dest'],
                                 'returnInfo': {'doc': '',
                                                'qualifiers': [],
                                                'type': None},
                                 'returnType': None,
                                 'static': False,
                                 'typeQualifiers': {'dest': ['unsigned',
                                                             '*']},
                                 'types': {'dest': 'uchar'}}],
                        'valid': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\nQueries whether the UUID is valid.',
                                   'inArgs': [],
                                   'outArgs': [],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': 'bool'},
                                   'returnType': 'bool',
                                   'static': False,
                                   'typeQualifiers': {},
                                   'types': {}}]},
            'pymelEnums': {}},
  'MVaryingParameter': {'enums': {'MVaryingParameterSemantic': {'valueDocs': {'binormal': '',
                                                                              'color': '',
                                                                              'kBinormal': '',
                                                                              'kColor': '',
                                                                              'kNoSemantic': '',
                                                                              'kNormal': '',
                                                                              'kPosition': '',
                                                                              'kTangent': '',
                                                                              'kTexCoord': '',
                                                                              'kWeight': '',
                                                                              'noSemantic': '',
                                                                              'normal': '',
                                                                              'position': '',
                                                                              'tangent': '',
                                                                              'texCoord': '',
                                                                              'weight': ''},
                                                                'values': "Enum('MVaryingParameterSemantic', {'kNoSemantic': 0, 'kPosition': 1, 'kNormal': 2, 'kTexCoord': 3, 'kColor': 4, 'kWeight': 5, 'kTangent': 7, 'kBinormal': 8})"},
                                  'MVaryingParameterType': {'valueDocs': {'char': '',
                                                                          'double': '',
                                                                          'float': '',
                                                                          'int16': '',
                                                                          'int32': '',
                                                                          'invalidParameter': '',
                                                                          'kChar': '',
                                                                          'kDouble': '',
                                                                          'kFloat': '',
                                                                          'kInt16': '',
                                                                          'kInt32': '',
                                                                          'kInvalidParameter': '',
                                                                          'kStructure': '',
                                                                          'kUnsignedChar': '',
                                                                          'kUnsignedInt16': '',
                                                                          'kUnsignedInt32': '',
                                                                          'structure': '',
                                                                          'unsignedChar': '',
                                                                          'unsignedInt16': '',
                                                                          'unsignedInt32': ''},
                                                            'values': "Enum('MVaryingParameterType', {'kInvalidParameter': -1, 'kStructure': 0, 'kFloat': 1, 'kDouble': 2, 'kChar': 3, 'kUnsignedChar': 4, 'kInt16': 5, 'kUnsignedInt16': 6, 'kInt32': 7, 'kUnsignedInt32': 8})"}},
                        'methods': {'addElement': [{'argInfo': {'child': {'doc': 'the parameter to add to the structure.',
                                                                          'type': 'MVaryingParameter'}},
                                                    'args': [('child',
                                                              'MVaryingParameter',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nAdd a child element to this parameter. This operation is only valid for parameters of type kStructure.',
                                                    'inArgs': ['child'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'child': ['const',
                                                                                 '&']},
                                                    'types': {'child': 'MVaryingParameter'}}],
                                    'destinationSet': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet the destination Set of this parameter',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'dimension': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the dimension of this parameter',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'int'},
                                                   'returnType': 'int',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'getBuffer': [{'argInfo': {'count': {'doc': 'the number of values returned for this parameter (e.g. there are 426 normals)',
                                                                         'type': 'uint'},
                                                               'data': {'doc': 'returns a pointer to the data (or NULL if the parameter is not available). ',
                                                                        'type': 'void'},
                                                               'elements': {'doc': 'the number of elements specified for this parameter (e.g. is it 3 floats or 4 floats?) ',
                                                                            'type': 'uint'},
                                                               'geometry': {'doc': 'the geometry cache the data should be retrieved from. This corresponds to the shape (e.g. mesh) you want the data for. ',
                                                                            'type': 'MGeometryLegacy'}},
                                                   'args': [('geometry',
                                                             'MGeometryLegacy',
                                                             'in'),
                                                            ('data',
                                                             'void',
                                                             'out'),
                                                            ('elements',
                                                             'uint',
                                                             'out'),
                                                            ('count',
                                                             'uint',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nGet the data for this parameter as a system memory buffer.',
                                                   'inArgs': ['geometry'],
                                                   'outArgs': ['data',
                                                               'elements',
                                                               'count'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'count': ['unsigned',
                                                                                '&'],
                                                                      'data': ['const',
                                                                               '*&'],
                                                                      'elements': ['unsigned',
                                                                                   '&'],
                                                                      'geometry': ['&']},
                                                   'types': {'count': 'uint',
                                                             'data': 'void',
                                                             'elements': 'uint',
                                                             'geometry': 'MGeometryLegacy'}}],
                                    'getElement': [{'argInfo': {'i': {'doc': 'The index of the structure element to return.',
                                                                      'type': 'uint'}},
                                                    'args': [('i',
                                                              'uint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet an element within a structure. This operation is only valid for parameters of type kStructure.',
                                                    'inArgs': ['i'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The structure element. This will be a NULL element if an invalid index was specified. ',
                                                                   'qualifiers': [],
                                                                   'type': 'MVaryingParameter'},
                                                    'returnType': 'MVaryingParameter',
                                                    'static': False,
                                                    'typeQualifiers': {'i': ['unsigned']},
                                                    'types': {'i': 'uint'}}],
                                    'getElementSize': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet the size in bytes of one element of this parameter.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'int'},
                                                        'returnType': 'int',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'getMaximumStride': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nGet the maximum stride of this parameter in bytes. For parameter that accept a range of element counts, this corresponds to the maximum number of elements the parameter supports.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': 'int'},
                                                          'returnType': 'int',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                    'getSourceSetName': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nIf the current data type supports data sets (e.g. uv sets, color sets), get the name of the data set populating this parameter. This method will only return a useful value when called on leaf-level parameters (e.g. structures do not have sources, only the elements of a structure have sources).',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The current source set of this parameter ',
                                                                         'qualifiers': [],
                                                                         'type': 'MString'},
                                                          'returnType': 'MString',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                    'getSourceType': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nGet the type of data (e.g. position, normal, uv) currently populating this parameter. This method will only return a useful value when called on leaf-level parameters (e.g. structures do not have sources, only the elements of a structure have sources).',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The current data type populating of this parameter ',
                                                                      'qualifiers': [],
                                                                      'type': ('MVaryingParameter',
                                                                               'MVaryingParameterSemantic')},
                                                       'returnType': ('MVaryingParameter',
                                                                      'MVaryingParameterSemantic'),
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                    'getUpdateId': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the update id. The update id is increased every time the parameter sources or sourceSet are changed. A plugin can compare the update id value between subsequent calls to this function to know if the source has changed since the last call.  Returns: The update id  \n',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'name': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the name of this parameter',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of this parameter ',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'numElements': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nGet the number of elements in this structure. This operation is only valid for parameters of type kStructure.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The number of elements in this structure. ',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'removeElements': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nRemove all child elements from a structure. This operation is only valid for parameters of type kStructure.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'semantic': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nGet the semantic of this parameter',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The semantic of this parameter ',
                                                                 'qualifiers': [],
                                                                 'type': ('MVaryingParameter',
                                                                          'MVaryingParameterSemantic')},
                                                  'returnType': ('MVaryingParameter',
                                                                 'MVaryingParameterSemantic'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'semanticName': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nGet the semantic name assigned to this parameter The semanticName is used to identify a custom vertex stream request in order to fill the stream with the appropriate data requested by a shader override.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                    'setSource': [{'argInfo': {'setName': {'doc': 'the specific data set to use for parameter types which support data sets, such as UV and color.',
                                                                           'type': 'MString'},
                                                               'type': {'doc': 'the type of data to populate this parameter with ',
                                                                        'type': ('MVaryingParameter',
                                                                                 'MVaryingParameterSemantic')}},
                                                   'args': [('type',
                                                             ('MVaryingParameter',
                                                              'MVaryingParameterSemantic'),
                                                             'in'),
                                                            ('setName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nWhile the source of geometry parameters is usually configured by the artist through Maya\'s user interface, this method allows you to programatically set the source of a geometry parameter, including both the data type (e.g. position, normal, etc) and an optional set name (e.g. UV set "map1"). This is useful for implementing custom default values or shader operations.',
                                                   'inArgs': ['type',
                                                              'setName'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'setName': ['const',
                                                                                  '&'],
                                                                      'type': []},
                                                   'types': {'setName': 'MString',
                                                             'type': ('MVaryingParameter',
                                                                      'MVaryingParameterSemantic')}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nGet the type of this parameter',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': ('MVaryingParameter',
                                                                      'MVaryingParameterType')},
                                              'returnType': ('MVaryingParameter',
                                                             'MVaryingParameterType'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {'MVaryingParameterSemantic': "Enum('MVaryingParameterSemantic', [('noSemantic', 0), ('kNoSemantic', 0), ('position', 1), ('kPosition', 1), ('normal', 2), ('kNormal', 2), ('texCoord', 3), ('kTexCoord', 3), ('color', 4), ('kColor', 4), ('weight', 5), ('kWeight', 5), ('tangent', 7), ('kTangent', 7), ('binormal', 8), ('kBinormal', 8)], multiKeys=True)",
                                       'MVaryingParameterType': "Enum('MVaryingParameterType', [('invalidParameter', -1), ('kInvalidParameter', -1), ('structure', 0), ('kStructure', 0), ('float', 1), ('kFloat', 1), ('double', 2), ('kDouble', 2), ('char', 3), ('kChar', 3), ('unsignedChar', 4), ('kUnsignedChar', 4), ('int16', 5), ('kInt16', 5), ('unsignedInt16', 6), ('kUnsignedInt16', 6), ('int32', 7), ('kInt32', 7), ('unsignedInt32', 8), ('kUnsignedInt32', 8)], multiKeys=True)"}},
  'MVaryingParameterList': {'enums': {},
                            'invertibles': [('setElement', 'getElement'),
                                            ('setLength', 'length')],
                            'methods': {'append': [{'argInfo': {'element': {'doc': 'The new parameter to append ',
                                                                            'type': 'MVaryingParameter'}},
                                                    'args': [('element',
                                                              'MVaryingParameter',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nAppend a new parameter to this end of this list.',
                                                    'inArgs': ['element'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'element': ['const',
                                                                                   '&']},
                                                    'types': {'element': 'MVaryingParameter'}}],
                                        'getElement': [{'argInfo': {'n': {'doc': 'The index of the element to return',
                                                                          'type': 'int'}},
                                                        'args': [('n',
                                                                  'int',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nGet the nth parameter in this list.',
                                                        'inArgs': ['n'],
                                                        'inverse': ('setElement',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The nth parameter in the list ',
                                                                       'qualifiers': [],
                                                                       'type': 'MVaryingParameter'},
                                                        'returnType': 'MVaryingParameter',
                                                        'static': False,
                                                        'typeQualifiers': {'n': []},
                                                        'types': {'n': 'int'}}],
                                        'length': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nGet the number of parameters in this list.',
                                                    'inArgs': [],
                                                    'inverse': ('setLength',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'int'},
                                                    'returnType': 'int',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                        'setElement': [{'argInfo': {'n': {'doc': 'The index of the element to set ',
                                                                          'type': 'int'},
                                                                    'p': {'doc': 'The value to set',
                                                                          'type': 'MVaryingParameter'}},
                                                        'args': [('n',
                                                                  'int',
                                                                  'in'),
                                                                 ('p',
                                                                  'MVaryingParameter',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nSet the nth parameter in this list.',
                                                        'inArgs': ['n',
                                                                   'p'],
                                                        'inverse': ('getElement',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'n': [],
                                                                           'p': ['const',
                                                                                 '&']},
                                                        'types': {'n': 'int',
                                                                  'p': 'MVaryingParameter'}}],
                                        'setLength': [{'argInfo': {'n': {'doc': 'The number of parameters in this list. ',
                                                                         'type': 'int'}},
                                                       'args': [('n',
                                                                 'int',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\r\nSet the number of parameters in this list. If this is greater than the current number of parameters in the list, the caller is responsible for setting the new parameters to valid values using setElement.',
                                                       'inArgs': ['n'],
                                                       'inverse': ('length',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'n': []},
                                                       'types': {'n': 'int'}}]},
                            'pymelEnums': {},
                            'pymelMethods': {'length': 'getLength'}},
  'MVector': {'enums': {'Axis': {'valueDocs': {'kWaxis': '',
                                               'kXaxis': '',
                                               'kYaxis': '',
                                               'kZaxis': '',
                                               'waxis': '',
                                               'xaxis': '',
                                               'yaxis': '',
                                               'zaxis': ''},
                                 'values': "Enum('Axis', {'kXaxis': 0, 'kYaxis': 1, 'kZaxis': 2, 'kWaxis': 3})"}},
              'methods': {'__add__': [{'argInfo': {'other': {'doc': 'Vector to add. ',
                                                             'type': 'MVector'}},
                                       'args': [('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe vector addition operator.',
                                       'inArgs': ['other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&']},
                                       'types': {'other': 'MVector'}}],
                          '__div__': [{'argInfo': {'scalar': {'doc': 'Division factor. ',
                                                              'type': 'double'}},
                                       'args': [('scalar',
                                                 'double',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe division operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'scalar': []},
                                       'types': {'scalar': 'double'}}],
                          '__eq__': [{'argInfo': {'other': {'doc': 'The vector to compare to.',
                                                            'type': 'MVector'}},
                                      'args': [('other',
                                                'MVector',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe vector equality operator. This returns true if all three of the x, y, and z components are identical.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Bool true if the vectors are identical and false otherwise. ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MVector'}}],
                          '__getitem__': [{'argInfo': {'i': {'doc': 'value indicating which component to return ',
                                                             'type': 'uint'}},
                                           'args': [('i', 'uint', 'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nThe index operator. If its argument is 0 it will return the x component of the vector. If its argument is 1 it will return the y component of the vector. Otherwise it will return the z component of the vector.',
                                           'inArgs': ['i'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {'i': ['unsigned']},
                                           'types': {'i': 'uint'}},
                                          {'argInfo': {'i': {'doc': 'value indicating which component to return ',
                                                             'type': 'uint'}},
                                           'args': [('i', 'uint', 'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                           'inArgs': ['i'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['&'],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {'i': ['unsigned']},
                                           'types': {'i': 'uint'}}],
                          '__iadd__': [{'argInfo': {'other': {'doc': 'Vector to add. ',
                                                              'type': 'MVector'}},
                                        'args': [('other',
                                                  'MVector',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place vector addition operator.',
                                        'inArgs': ['other'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'other': ['const',
                                                                     '&']},
                                        'types': {'other': 'MVector'}}],
                          '__idiv__': [{'argInfo': {'scalar': {'doc': 'Division factor. ',
                                                               'type': 'double'}},
                                        'args': [('scalar',
                                                  'double',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place division operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'scalar': []},
                                        'types': {'scalar': 'double'}}],
                          '__imul__': [{'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                               'type': 'int'}},
                                        'args': [('scalar', 'int', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'scalar': []},
                                        'types': {'scalar': 'int'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                               'type': 'short'}},
                                        'args': [('scalar',
                                                  'short',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'scalar': []},
                                        'types': {'scalar': 'short'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                               'type': 'uint'}},
                                        'args': [('scalar',
                                                  'uint',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'scalar': ['unsigned']},
                                        'types': {'scalar': 'uint'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                               'type': 'short'}},
                                        'args': [('scalar',
                                                  'short',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'scalar': ['unsigned']},
                                        'types': {'scalar': 'short'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                               'type': 'float'}},
                                        'args': [('scalar',
                                                  'float',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'scalar': []},
                                        'types': {'scalar': 'float'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                               'type': 'double'}},
                                        'args': [('scalar',
                                                  'double',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'scalar': []},
                                        'types': {'scalar': 'double'}},
                                       {'argInfo': {'right': {'doc': '',
                                                              'type': 'MMatrix'}},
                                        'args': [('right',
                                                  'MMatrix',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place matrix multiplication operator. \r\n',
                                        'inArgs': ['right'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'right': ['const',
                                                                     '&']},
                                        'types': {'right': 'MMatrix'}}],
                          '__isub__': [{'argInfo': {'other': {'doc': 'Vector to subtract. ',
                                                              'type': 'MVector'}},
                                        'args': [('other',
                                                  'MVector',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nThe in place vector subtraction operator.',
                                        'inArgs': ['other'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'other': ['const',
                                                                     '&']},
                                        'types': {'other': 'MVector'}}],
                          '__mul__': [{'argInfo': {'right': {'doc': 'Vector to take the dot product with. ',
                                                             'type': 'MVector'}},
                                       'args': [('right',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe dot product operator.',
                                       'inArgs': ['right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'double'},
                                       'returnType': 'double',
                                       'static': False,
                                       'typeQualifiers': {'right': ['const',
                                                                    '&']},
                                       'types': {'right': 'MVector'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'int'}},
                                       'args': [('scalar', 'int', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'scalar': []},
                                       'types': {'scalar': 'int'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'short'}},
                                       'args': [('scalar',
                                                 'short',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'scalar': []},
                                       'types': {'scalar': 'short'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'uint'}},
                                       'args': [('scalar', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'scalar': ['unsigned']},
                                       'types': {'scalar': 'uint'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'short'}},
                                       'args': [('scalar',
                                                 'short',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'scalar': ['unsigned']},
                                       'types': {'scalar': 'short'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'float'}},
                                       'args': [('scalar',
                                                 'float',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'scalar': []},
                                       'types': {'scalar': 'float'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'double'}},
                                       'args': [('scalar',
                                                 'double',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'scalar': []},
                                       'types': {'scalar': 'double'}},
                                      {'argInfo': {'right': {'doc': '',
                                                             'type': 'MMatrix'}},
                                       'args': [('right',
                                                 'MMatrix',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe matrix multiplication operator. \r\n',
                                       'inArgs': ['right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'right': ['const',
                                                                    '&']},
                                       'types': {'right': 'MMatrix'}},
                                      {'argInfo': {'left': {'doc': 'the matrix on the left ',
                                                            'type': 'MMatrix'},
                                                   'right': {'doc': 'the vector on the right',
                                                             'type': 'MVector'}},
                                       'args': [('left',
                                                 'MMatrix',
                                                 'in'),
                                                ('right',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['left', 'right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The MVector resulting from the multiplication ',
                                                      'qualifiers': ['MVector'],
                                                      'type': ('MVector',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MVector',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'left': ['const',
                                                                   '&'],
                                                          'right': ['const',
                                                                    '&']},
                                       'types': {'left': 'MMatrix',
                                                 'right': 'MVector'}},
                                      {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                             'type': 'MVector'},
                                                   'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'int'}},
                                       'args': [('scalar', 'int', 'in'),
                                                ('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['scalar', 'other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The scales vector. ',
                                                      'qualifiers': ['MVector'],
                                                      'type': ('MVector',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MVector',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&'],
                                                          'scalar': []},
                                       'types': {'other': 'MVector',
                                                 'scalar': 'int'}},
                                      {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                             'type': 'MVector'},
                                                   'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'short'}},
                                       'args': [('scalar',
                                                 'short',
                                                 'in'),
                                                ('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['scalar', 'other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The scales vector. ',
                                                      'qualifiers': ['MVector'],
                                                      'type': ('MVector',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MVector',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&'],
                                                          'scalar': []},
                                       'types': {'other': 'MVector',
                                                 'scalar': 'short'}},
                                      {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                             'type': 'MVector'},
                                                   'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'uint'}},
                                       'args': [('scalar', 'uint', 'in'),
                                                ('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['scalar', 'other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The scales vector. ',
                                                      'qualifiers': ['MVector'],
                                                      'type': ('MVector',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MVector',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&'],
                                                          'scalar': ['unsigned']},
                                       'types': {'other': 'MVector',
                                                 'scalar': 'uint'}},
                                      {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                             'type': 'MVector'},
                                                   'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'short'}},
                                       'args': [('scalar',
                                                 'short',
                                                 'in'),
                                                ('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['scalar', 'other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The scales vector. ',
                                                      'qualifiers': ['MVector'],
                                                      'type': ('MVector',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MVector',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&'],
                                                          'scalar': ['unsigned']},
                                       'types': {'other': 'MVector',
                                                 'scalar': 'short'}},
                                      {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                             'type': 'MVector'},
                                                   'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'float'}},
                                       'args': [('scalar',
                                                 'float',
                                                 'in'),
                                                ('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['scalar', 'other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The scales vector. ',
                                                      'qualifiers': ['MVector'],
                                                      'type': ('MVector',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MVector',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&'],
                                                          'scalar': []},
                                       'types': {'other': 'MVector',
                                                 'scalar': 'float'}},
                                      {'argInfo': {'other': {'doc': 'Vector to scale.',
                                                             'type': 'MVector'},
                                                   'scalar': {'doc': 'Scale factor. ',
                                                              'type': 'double'}},
                                       'args': [('scalar',
                                                 'double',
                                                 'in'),
                                                ('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                       'inArgs': ['scalar', 'other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The scales vector. ',
                                                      'qualifiers': ['MVector'],
                                                      'type': ('MVector',
                                                               'OPENMAYA_EXPORT')},
                                       'returnType': ('MVector',
                                                      'OPENMAYA_EXPORT'),
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&'],
                                                          'scalar': []},
                                       'types': {'other': 'MVector',
                                                 'scalar': 'double'}}],
                          '__ne__': [{'argInfo': {'other': {'doc': 'The vector to compare to.',
                                                            'type': 'MVector'}},
                                      'args': [('other',
                                                'MVector',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nThe vector inequality operator. This returns false if all three of the x, y, and z components are identical.',
                                      'inArgs': ['other'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Bool false if the vectors are identical and true otherwise. ',
                                                     'qualifiers': [],
                                                     'type': 'bool'},
                                      'returnType': 'bool',
                                      'static': False,
                                      'typeQualifiers': {'other': ['const',
                                                                   '&']},
                                      'types': {'other': 'MVector'}}],
                          '__sub__': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe unary minus operator. Negates the value of each of the x, y, and z components of the vector. \r\n',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}},
                                      {'argInfo': {'other': {'doc': 'Vector to substract. ',
                                                             'type': 'MVector'}},
                                       'args': [('other',
                                                 'MVector',
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\r\nThe vector subtraction operator.',
                                       'inArgs': ['other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&']},
                                       'types': {'other': 'MVector'}}],
                          'angle': [{'argInfo': {'other': {'doc': 'the vector from which to compute the angle.',
                                                           'type': 'MVector'}},
                                     'args': [('other', 'MVector', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '\r\nReturns the angle in radians between the vector and the one passed as an argument.',
                                     'inArgs': ['other'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'The angle in radians ',
                                                    'qualifiers': [],
                                                    'type': 'double'},
                                     'returnType': 'double',
                                     'static': False,
                                     'typeQualifiers': {'other': ['const',
                                                                  '&']},
                                     'types': {'other': 'MVector'}}],
                          'get': [{'argInfo': {'dest': {'doc': 'the array of 3 doubles into which the results are placed.',
                                                        'type': 'double__array3'}},
                                   'args': [('dest',
                                             'double__array3',
                                             'out')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': '\r\nExtracts the x, y, and z components of the vector and places them in elements 0, 1, and 2 of the double array passed.',
                                   'inArgs': [],
                                   'outArgs': ['dest'],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': None},
                                   'returnType': None,
                                   'static': False,
                                   'typeQualifiers': {'dest': []},
                                   'types': {'dest': 'double__array3'}}],
                          'isEquivalent': [{'argInfo': {'other': {'doc': 'The vector to compare to. ',
                                                                  'type': 'MVector'},
                                                        'tol': {'doc': 'The tolerance to use during the comparison.',
                                                                'type': 'double'}},
                                            'args': [('other',
                                                      'MVector',
                                                      'in'),
                                                     ('tol',
                                                      'double',
                                                      'in')],
                                            'defaults': {'tol': 1e-10},
                                            'deprecated': False,
                                            'doc': '\r\nReturns true if the vector and the one passed as an argument are equal to each other within the specified tolerance.',
                                            'inArgs': ['other', 'tol'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Bool true if the vectors are equivalent and false otherwise. ',
                                                           'qualifiers': [],
                                                           'type': 'bool'},
                                            'returnType': 'bool',
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&'],
                                                               'tol': []},
                                            'types': {'other': 'MVector',
                                                      'tol': 'double'}}],
                          'isParallel': [{'argInfo': {'other': {'doc': 'the vector to compare to ',
                                                                'type': 'MVector'},
                                                      'tol': {'doc': 'the tolerance to use during the comparison',
                                                              'type': 'double'}},
                                          'args': [('other',
                                                    'MVector',
                                                    'in'),
                                                   ('tol',
                                                    'double',
                                                    'in')],
                                          'defaults': {'tol': 1e-10},
                                          'deprecated': False,
                                          'doc': '\r\nReturns true if the current vector and the one passed as an argument are parallel to each other within the specified tolerance.',
                                          'inArgs': ['other', 'tol'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'true if the vectors are parallel and false otherwise ',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'other': ['const',
                                                                       '&'],
                                                             'tol': []},
                                          'types': {'other': 'MVector',
                                                    'tol': 'double'}}],
                          'length': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn the length of the vector. \r\n  Reprocessed example  \n Examples: \n \n   \n meshOpFtyAction.cpp ,  simpleFluidEmitter.cpp ,  simpleSpring.cpp , and  torusField.cpp . \n \n',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                          'normal': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\r\nReturn a normalized copy of this vector. \r\n',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'MVector'},
                                      'returnType': 'MVector',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                          'normalize': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nPerforms an in place normalization of the vector',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'rotateBy': [{'argInfo': {'w': {'doc': 'The w component of the quaternion.',
                                                          'type': 'double'},
                                                    'x': {'doc': 'The x component of the quaternion. ',
                                                          'type': 'double'},
                                                    'y': {'doc': 'The y component of the quaternion. ',
                                                          'type': 'double'},
                                                    'z': {'doc': 'The z component of the quaternion. ',
                                                          'type': 'double'}},
                                        'args': [('x', 'double', 'in'),
                                                 ('y', 'double', 'in'),
                                                 ('z', 'double', 'in'),
                                                 ('w', 'double', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the vector that represents the rotation of this vector by the given quaternion.',
                                        'inArgs': ['x', 'y', 'z', 'w'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The resulting vector. ',
                                                       'qualifiers': [],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'w': [],
                                                           'x': [],
                                                           'y': [],
                                                           'z': []},
                                        'types': {'w': 'double',
                                                  'x': 'double',
                                                  'y': 'double',
                                                  'z': 'double'}},
                                       {'argInfo': {'order': {'doc': 'Order in which to apply the XYZ components of the rotation.',
                                                              'type': ('MTransformationMatrix',
                                                                       'RotationOrder')},
                                                    'rotXYZ': {'doc': 'Array containing the X, Y, and Z axis rotations, respectively. ',
                                                               'type': 'double__array3'}},
                                        'args': [('rotXYZ',
                                                  'double__array3',
                                                  'in'),
                                                 ('order',
                                                  ('MTransformationMatrix',
                                                   'RotationOrder'),
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the vector that represents the rotation of this vector by the given XYZ rotational values, applied according to the given rotation order.',
                                        'inArgs': ['rotXYZ', 'order'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The resulting vector. ',
                                                       'qualifiers': [],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'order': [],
                                                           'rotXYZ': ['const']},
                                        'types': {'order': ('MTransformationMatrix',
                                                            'RotationOrder'),
                                                  'rotXYZ': 'double__array3'}},
                                       {'argInfo': {'angle': {'doc': 'The rotation angle about the axis.',
                                                              'type': 'double'},
                                                    'axis': {'doc': 'The axis to rotate about. ',
                                                             'type': ('MVector',
                                                                      'Axis')}},
                                        'args': [('axis',
                                                  ('MVector', 'Axis'),
                                                  'in'),
                                                 ('angle',
                                                  'double',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the vector that represents the rotation of this vector by the given angle about the given axis.',
                                        'inArgs': ['axis', 'angle'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The resulting vector. ',
                                                       'qualifiers': [],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'angle': ['const'],
                                                           'axis': []},
                                        'types': {'angle': 'double',
                                                  'axis': ('MVector',
                                                           'Axis')}},
                                       {'argInfo': {'q': {'doc': 'The quaternion rotation by which the vector will be rotated to produce the resulting vector.',
                                                          'type': 'MQuaternion'}},
                                        'args': [('q',
                                                  'MQuaternion',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the vector that represents the rotation of this vector by the given quaternion.',
                                        'inArgs': [],
                                        'outArgs': ['q'],
                                        'returnInfo': {'doc': 'The resulting vector. ',
                                                       'qualifiers': [],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'q': ['const',
                                                                 '&']},
                                        'types': {'q': 'MQuaternion'}},
                                       {'argInfo': {'e': {'doc': 'The euler rotation by which the vector will be rotated to produce the resulting vector.',
                                                          'type': 'MEulerRotation'}},
                                        'args': [('e',
                                                  'MEulerRotation',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the vector that represents the rotation of this vector by the given euler rotation.',
                                        'inArgs': [],
                                        'outArgs': ['e'],
                                        'returnInfo': {'doc': 'The resulting vector. ',
                                                       'qualifiers': [],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'e': ['const',
                                                                 '&']},
                                        'types': {'e': 'MEulerRotation'}}],
                          'rotateTo': [{'argInfo': {'other': {'doc': 'The other vector into which this vector will be rotated to produce the resulting quaternion rotation.',
                                                              'type': 'MVector'}},
                                        'args': [('other',
                                                  'MVector',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nReturns the quaternion that represents the rotation of this vector into the other vector about their mutually perpendicular axis.',
                                        'inArgs': [],
                                        'outArgs': ['other'],
                                        'returnInfo': {'doc': 'The resulting quaternion. ',
                                                       'qualifiers': [],
                                                       'type': 'MQuaternion'},
                                        'returnType': 'MQuaternion',
                                        'static': False,
                                        'typeQualifiers': {'other': ['const',
                                                                     '&']},
                                        'types': {'other': 'MVector'}}],
                          'transformAsNormal': [{'argInfo': {'matrix': {'doc': 'the transformation matrix',
                                                                        'type': 'MMatrix'}},
                                                 'args': [('matrix',
                                                           'MMatrix',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nThis method treats the vector as a normal vector and returns a transformed copy of the vector.',
                                                 'inArgs': ['matrix'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The resulting transformed vector ',
                                                                'qualifiers': [],
                                                                'type': 'MVector'},
                                                 'returnType': 'MVector',
                                                 'static': False,
                                                 'typeQualifiers': {'matrix': ['const',
                                                                               '&']},
                                                 'types': {'matrix': 'MMatrix'}}]},
              'pymelEnums': {'Axis': "Enum('Axis', [('xaxis', 0), ('kXaxis', 0), ('yaxis', 1), ('kYaxis', 1), ('zaxis', 2), ('kZaxis', 2), ('waxis', 3), ('kWaxis', 3)], multiKeys=True)"}},
  'MVectorArray': {'enums': {},
                   'invertibles': [('setSizeIncrement', 'sizeIncrement'),
                                   ('setLength', 'length')],
                   'methods': {'__getitem__': [{'argInfo': {'index': {'doc': 'the index of the element whose value is to be returned',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nIndex operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The value of the indicated element. ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}},
                                               {'argInfo': {'index': {'doc': 'the index of the desired element',
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nNO SCRIPT SUPPORT. \r\n',
                                                'inArgs': ['index'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'A reference to the indicated element ',
                                                               'qualifiers': ['&'],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'append': [{'argInfo': {'element': {'doc': 'the value for the new last element',
                                                                   'type': 'MVector'}},
                                           'args': [('element',
                                                     'MVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nAdds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': ['const',
                                                                          '&']},
                                           'types': {'element': 'MVector'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nClear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                               'copy': [{'argInfo': {'source': {'doc': 'array to copy from',
                                                                'type': 'MVectorArray'}},
                                         'args': [('source',
                                                   'MVectorArray',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nCopy the contents of the source array to this array.',
                                         'inArgs': ['source'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'source': ['const',
                                                                       '&']},
                                         'types': {'source': 'MVectorArray'}}],
                               'get': [{'argInfo': {'array': {'doc': 'the array to populate',
                                                              'type': 'double__array'}},
                                        'args': [('array',
                                                  'double__array',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopy the elements of the array into the given C++ array of double arrays. No checking is done to ensure that the destination C++ array of double arrays is large enough to hold all the elements of the instance.',
                                        'inArgs': [],
                                        'outArgs': ['array'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'array': []},
                                        'types': {'array': 'double__array'}},
                                       {'argInfo': {'array': {'doc': 'the array to populate',
                                                              'type': 'float__array'}},
                                        'args': [('array',
                                                  'float__array',
                                                  'out')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nCopy the elements of the array into the given C++ array of float arrays. No checking is done to ensure that the destination C++ array of floats arrays is large enough to hold all the elements of the instance.',
                                        'inArgs': [],
                                        'outArgs': ['array'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'array': []},
                                        'types': {'array': 'float__array'}}],
                               'insert': [{'argInfo': {'element': {'doc': 'the new value to insert into the array ',
                                                                   'type': 'MVector'},
                                                       'index': {'doc': 'the index of the element to set to the the new value',
                                                                 'type': 'uint'}},
                                           'args': [('element',
                                                     'MVector',
                                                     'in'),
                                                    ('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nInserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.',
                                           'inArgs': ['element', 'index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'element': ['const',
                                                                          '&'],
                                                              'index': ['unsigned']},
                                           'types': {'element': 'MVector',
                                                     'index': 'uint'}}],
                               'length': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nReturns the number of elements in the instance.',
                                           'inArgs': [],
                                           'inverse': ('setLength',
                                                       False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The number of elements in the instance ',
                                                          'qualifiers': [],
                                                          'type': 'int'},
                                           'returnType': 'int',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'remove': [{'argInfo': {'index': {'doc': 'index of the element to be removed',
                                                                 'type': 'uint'}},
                                           'args': [('index',
                                                     'uint',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nRemove the array element at the given index. All array elements following the removed element are shifted toward the first element.',
                                           'inArgs': ['index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'index': ['unsigned']},
                                           'types': {'index': 'uint'}}],
                               'set': [{'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'MVector'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'MVector',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the value of the indicated element to the indicated  MVector  value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': ['const',
                                                                       '&'],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'MVector',
                                                  'index': 'uint'}},
                                       {'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'double__array3'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'double__array3',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the value of the indicated element to the indicated double array value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': [],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'double__array3',
                                                  'index': 'uint'}},
                                       {'argInfo': {'element': {'doc': 'the new value for the indicated element ',
                                                                'type': 'float__array3'},
                                                    'index': {'doc': 'the index of the element that is to be set to the the new value',
                                                              'type': 'uint'}},
                                        'args': [('element',
                                                  'float__array3',
                                                  'in'),
                                                 ('index', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': '\r\nSets the value of the indicated element to the indicated float array value.',
                                        'inArgs': ['element', 'index'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'element': [],
                                                           'index': ['unsigned']},
                                        'types': {'element': 'float__array3',
                                                  'index': 'uint'}}],
                               'setLength': [{'argInfo': {'length': {'doc': 'the new size of the array ',
                                                                     'type': 'uint'}},
                                              'args': [('length',
                                                        'uint',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSet the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).',
                                              'inArgs': ['length'],
                                              'inverse': ('length', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'length': ['unsigned']},
                                              'types': {'length': 'uint'}}],
                               'setSizeIncrement': [{'argInfo': {'newIncrement': {'doc': 'the new increment ',
                                                                                  'type': 'uint'}},
                                                     'args': [('newIncrement',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nSet the size by which the array will be expanded whenever expansion is necessary.',
                                                     'inArgs': ['newIncrement'],
                                                     'inverse': ('sizeIncrement',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'newIncrement': ['unsigned']},
                                                     'types': {'newIncrement': 'uint'}}],
                               'sizeIncrement': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nReturn the size by which the array will be expanded whenever expansion is necessary.',
                                                  'inArgs': [],
                                                  'inverse': ('setSizeIncrement',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'length': 'getLength',
                                    'sizeIncrement': 'getSizeIncrement'}},
  'MViewportRenderer': {'enums': {'RenderingAPI': {'valueDocs': {'direct3D': 'Renderer uses hardware Direct3D for rendering.',
                                                                 'kDirect3D': 'Renderer uses hardware Direct3D for rendering.',
                                                                 'kOpenGL': 'Renderer uses hardware OpenGL for rendering.',
                                                                 'kSoftware': 'Renderer renders using software.',
                                                                 'openGL': 'Renderer uses hardware OpenGL for rendering.',
                                                                 'software': 'Renderer renders using software.'},
                                                   'values': "Enum('RenderingAPI', {'kOpenGL': 0, 'kDirect3D': 1, 'kSoftware': 2})"},
                                  'RenderingOverride': {'valueDocs': {'kNoOverride': 'Override nothing.',
                                                                      'kOverrideAllDrawing': 'Override all drawing.',
                                                                      'kOverrideThenStandard': 'Override all drawing, then follow with a standard render pass.',
                                                                      'kOverrideThenUI': 'Override draw, then follow with a UI only render pass.',
                                                                      'noOverride': 'Override nothing.',
                                                                      'overrideAllDrawing': 'Override all drawing.',
                                                                      'overrideThenStandard': 'Override all drawing, then follow with a standard render pass.',
                                                                      'overrideThenUI': 'Override draw, then follow with a UI only render pass.'},
                                                        'values': "Enum('RenderingOverride', {'kNoOverride': 0, 'kOverrideAllDrawing': 1, 'kOverrideThenStandard': 2, 'kOverrideThenUI': 3})"}},
                        'invertibles': [('setRenderingOverride',
                                         'renderingOverride')],
                        'methods': {'UIname': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nReturn the name of the renderer as it should appear to users. \r\n',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['&'],
                                                               'type': 'MString'},
                                                'returnType': 'MString',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                    'deregisterRenderer': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nDeregister the renderer. \r\n',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                    'initialize': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nRenderer initialization. \r\n',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'name': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturn the internal name of the renderer. \r\n',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': ['&'],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'nativelySupports': [{'argInfo': {'api': {'doc': 'rendering API natively used by the render target ',
                                                                              'type': ('MViewportRenderer',
                                                                                       'RenderingAPI')},
                                                                      'version': {'doc': 'rendering API version of the API natively used by the render target',
                                                                                  'type': 'float'}},
                                                          'args': [('api',
                                                                    ('MViewportRenderer',
                                                                     'RenderingAPI'),
                                                                    'in'),
                                                                   ('version',
                                                                    'float',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': "\r\nQuery the native rendering API's supported by this renderer. \r\n",
                                                          'inArgs': ['api',
                                                                     'version'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'MViewportRenderer::RenderingAPI : rendering API. ',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {'api': [],
                                                                             'version': []},
                                                          'types': {'api': ('MViewportRenderer',
                                                                            'RenderingAPI'),
                                                                    'version': 'float'}}],
                                    'override': [{'argInfo': {'override': {'doc': 'render target override',
                                                                           'type': ('MViewportRenderer',
                                                                                    'RenderingOverride')}},
                                                  'args': [('override',
                                                            ('MViewportRenderer',
                                                             'RenderingOverride'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nCheck if override exists. \r\n',
                                                  'inArgs': ['override'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if the renderer overrides the render target override. ',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {'override': []},
                                                  'types': {'override': ('MViewportRenderer',
                                                                         'RenderingOverride')}}],
                                    'overrideThenStandardExclusion': [{'argInfo': {},
                                                                       'args': [],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': '\r\nRendering exclusion for standard pass of kOverrideThenStandard. \r\n',
                                                                       'inArgs': [],
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': 'int'},
                                                                       'returnType': 'int',
                                                                       'static': False,
                                                                       'typeQualifiers': {},
                                                                       'types': {}}],
                                    'registerRenderer': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nRegister the renderer. \r\n',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                    'render': [{'argInfo': {'info': {'doc': '',
                                                                     'type': 'MRenderingInfo'}},
                                                'args': [('info',
                                                          'MRenderingInfo',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nMethod which does the actual rendering. \r\n',
                                                'inArgs': ['info'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'info': ['const',
                                                                            '&']},
                                                'types': {'info': 'MRenderingInfo'}}],
                                    'renderingOverride': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\r\nReturn the override status. \r\n',
                                                           'inArgs': [],
                                                           'inverse': ('setRenderingOverride',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': ('MViewportRenderer',
                                                                                   'RenderingOverride')},
                                                           'returnType': ('MViewportRenderer',
                                                                          'RenderingOverride'),
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                    'setRenderingOverride': [{'argInfo': {'override': {'doc': 'override value to set ',
                                                                                       'type': ('MViewportRenderer',
                                                                                                'RenderingOverride')}},
                                                              'args': [('override',
                                                                        ('MViewportRenderer',
                                                                         'RenderingOverride'),
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '\r\nSet the rendering override for the renderer. \r\n',
                                                              'inArgs': ['override'],
                                                              'inverse': ('renderingOverride',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'override': []},
                                                              'types': {'override': ('MViewportRenderer',
                                                                                     'RenderingOverride')}}],
                                    'setUIName': [{'argInfo': {'name': {'doc': 'name to set ',
                                                                        'type': 'MString'}},
                                                   'args': [('name',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSet the name of the renderer as it should appear to users. \r\n',
                                                   'inArgs': ['name'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'name': ['const',
                                                                               '&']},
                                                   'types': {'name': 'MString'}}],
                                    'uninitialize': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\r\nRenderer cleanup. \r\n',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                        'pymelEnums': {'RenderingAPI': "Enum('RenderingAPI', [('openGL', 0), ('kOpenGL', 0), ('direct3D', 1), ('kDirect3D', 1), ('software', 2), ('kSoftware', 2)], multiKeys=True)",
                                       'RenderingOverride': "Enum('RenderingOverride', [('noOverride', 0), ('kNoOverride', 0), ('overrideAllDrawing', 1), ('kOverrideAllDrawing', 1), ('overrideThenStandard', 2), ('kOverrideThenStandard', 2), ('overrideThenUI', 3), ('kOverrideThenUI', 3)], multiKeys=True)"},
                        'pymelMethods': {'renderingOverride': 'getRenderingOverride'}},
  'MWeight': {'enums': {},
              'invertibles': [('setInfluence', 'influence'),
                              ('setSeam', 'seam')],
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nReturns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'influence': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nCurrent influence weight. \n',
                                         'inArgs': [],
                                         'inverse': ('setInfluence',
                                                     False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'float'},
                                         'returnType': 'float',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'seam': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': '\nCurrent seam weight. \n',
                                    'inArgs': [],
                                    'inverse': ('setSeam', False),
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': 'float'},
                                    'returnType': 'float',
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                          'setInfluence': [{'argInfo': {'influence': {'doc': 'The influence weight to set ',
                                                                      'type': 'float'}},
                                            'args': [('influence',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSet the influence weight.',
                                            'inArgs': ['influence'],
                                            'inverse': ('influence',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'influence': []},
                                            'types': {'influence': 'float'}}],
                          'setSeam': [{'argInfo': {'seam': {'doc': 'The seam weight to set ',
                                                            'type': 'float'}},
                                       'args': [('seam', 'float', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': '\nSet the seam weight.',
                                       'inArgs': ['seam'],
                                       'inverse': ('seam', True),
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {'seam': []},
                                       'types': {'seam': 'float'}}]},
              'pymelEnums': {},
              'pymelMethods': {'influence': 'getInfluence',
                               'seam': 'getSeam'}},
  'MaterialInputData': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MnCloth': {'enums': {},
              'invertibles': [('setThickness', 'getThickness'),
                              ('setInverseMass', 'getInverseMass'),
                              ('setVelocities', 'getVelocities'),
                              ('setPositions', 'getPositions'),
                              ('setBounce', 'getBounce'),
                              ('setFriction', 'getFriction')],
              'methods': {'createNCloth': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nCreates the underlying Maya TnCloth and sets this class to wrap it.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                          'getBounce': [{'argInfo': {'bounce': {'doc': 'the array will be filled with the bounce.',
                                                                'type': 'MFloatArray'}},
                                         'args': [('bounce',
                                                   'MFloatArray',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\ngets the bounce at each point of the underlying N cloth object.',
                                         'inArgs': [],
                                         'inverse': ('setBounce', False),
                                         'outArgs': ['bounce'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'bounce': ['&']},
                                         'types': {'bounce': 'MFloatArray'}}],
                          'getFriction': [{'argInfo': {'friction': {'doc': 'the array will be filled with the friction.',
                                                                    'type': 'MFloatArray'}},
                                           'args': [('friction',
                                                     'MFloatArray',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\ngets the friction at each point of the underlying N cloth object.',
                                           'inArgs': [],
                                           'inverse': ('setFriction',
                                                       False),
                                           'outArgs': ['friction'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'friction': ['&']},
                                           'types': {'friction': 'MFloatArray'}}],
                          'getInverseMass': [{'argInfo': {'inverseMass': {'doc': 'the array will be filled with the inverse masses.',
                                                                          'type': 'MFloatArray'}},
                                              'args': [('inverseMass',
                                                        'MFloatArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\ngets the inverseMass at each point of the underlying N cloth object.',
                                              'inArgs': [],
                                              'inverse': ('setInverseMass',
                                                          False),
                                              'outArgs': ['inverseMass'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'inverseMass': ['&']},
                                              'types': {'inverseMass': 'MFloatArray'}}],
                          'getNumVertices': [{'argInfo': {'numVerts': {'doc': 'Number of vertices.',
                                                                       'type': 'uint'}},
                                              'args': [('numVerts',
                                                        'uint',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nReturns the number of vertices in the underlying n Cloth',
                                              'inArgs': [],
                                              'outArgs': ['numVerts'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'numVerts': ['unsigned',
                                                                              '&']},
                                              'types': {'numVerts': 'uint'}}],
                          'getPositions': [{'argInfo': {'positions': {'doc': 'the array will be filled with the positions.',
                                                                      'type': 'MFloatPointArray'}},
                                            'args': [('positions',
                                                      'MFloatPointArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\ngets the positions of the points of the underlying N Object.',
                                            'inArgs': [],
                                            'inverse': ('setPositions',
                                                        False),
                                            'outArgs': ['positions'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'positions': ['&']},
                                            'types': {'positions': 'MFloatPointArray'}}],
                          'getThickness': [{'argInfo': {'radius': {'doc': 'the array will be filled with the thickness.',
                                                                   'type': 'MFloatArray'}},
                                            'args': [('radius',
                                                      'MFloatArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\ngets the thickness at each point of the underlying N cloth object.',
                                            'inArgs': [],
                                            'inverse': ('setThickness',
                                                        False),
                                            'outArgs': ['radius'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'radius': ['&']},
                                            'types': {'radius': 'MFloatArray'}}],
                          'getVelocities': [{'argInfo': {'velocities': {'doc': 'the array will be filled with the positions.',
                                                                        'type': 'MFloatPointArray'}},
                                             'args': [('velocities',
                                                       'MFloatPointArray',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\ngets the velocities of the points of the underlying N cloth object.',
                                             'inArgs': [],
                                             'inverse': ('setVelocities',
                                                         False),
                                             'outArgs': ['velocities'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'velocities': ['&']},
                                             'types': {'velocities': 'MFloatPointArray'}}],
                          'setAddCrossLinks': [{'argInfo': {'addCrossLinks': {'doc': 'value to set',
                                                                              'type': 'float'}},
                                                'args': [('addCrossLinks',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nFor faces with more than 3 vertices this will create additional stretch and bends links such that each vertex is connected to each other vertex. If this is off then the links will exactly match the meshes list of edges. For a quad meshes having addCrossLinks off would allow the cloth to shear, unless shear resistance was used.',
                                                'inArgs': ['addCrossLinks'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'addCrossLinks': []},
                                                'types': {'addCrossLinks': 'float'}}],
                          'setAirTightness': [{'argInfo': {'airTightness': {'doc': 'value to set',
                                                                            'type': 'float'}},
                                               'args': [('airTightness',
                                                         'float',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\r\nDefines the rate at which air can escape from the object, or how permiable the surface is. This is in addition to any physical holes in the model, which can be be capped or not using the seal holes method.',
                                               'inArgs': ['airTightness'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'airTightness': []},
                                               'types': {'airTightness': 'float'}}],
                          'setBendAngleDropoff': [{'argInfo': {'dropoff': {'doc': 'value to set',
                                                                           'type': 'float'}},
                                                   'args': [('dropoff',
                                                             'float',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDefines the way bend resistance changes with the angle. At higher values the bend will resist more at high angles then when the surface is nearly flat.',
                                                   'inArgs': ['dropoff'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'dropoff': []},
                                                   'types': {'dropoff': 'float'}}],
                          'setBendAngleScale': [{'argInfo': {'scale': {'doc': 'value to set',
                                                                       'type': 'float'}},
                                                 'args': [('scale',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nDefines the amount by which the rest state of the bend angle is scaled.',
                                                 'inArgs': ['scale'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'scale': []},
                                                 'types': {'scale': 'float'}}],
                          'setBendResistance': [{'argInfo': {'strength': {'doc': 'value to set',
                                                                          'type': 'float'}},
                                                 'args': [('strength',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nBend resistance measures the amount of attraction to the restAngle, which is defined between cvs on either side of an edge. Larger values will tend to make the surface more rigid and will take longer to compute.',
                                                 'inArgs': ['strength'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'strength': []},
                                                 'types': {'strength': 'float'}}],
                          'setBendRestAngleFromPositions': [{'argInfo': {'positions': {'doc': 'the array containing the position information',
                                                                                       'type': 'MFloatPointArray'}},
                                                             'args': [('positions',
                                                                       'MFloatPointArray',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSets the the bend rest angle from the list of positions for the underlying N Object This sets the shape that bend resistance is trying to achieve.',
                                                             'inArgs': ['positions'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'positions': ['const',
                                                                                              '&']},
                                                             'types': {'positions': 'MFloatPointArray'}}],
                          'setBounce': [{'argInfo': {'bounce': {'doc': 'value of bounce to set',
                                                                'type': 'float'}},
                                         'args': [('bounce',
                                                   'float',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nsets the bounce for every point in this mesh',
                                         'inArgs': ['bounce'],
                                         'inverse': ('getBounce', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'bounce': []},
                                         'types': {'bounce': 'float'}},
                                        {'argInfo': {'bounce': {'doc': 'value of bounce to set',
                                                                'type': 'float'}},
                                         'args': [('bounce',
                                                   'float',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\r\nsets the bounce on a per point basis in this mesh',
                                         'inArgs': ['bounce'],
                                         'inverse': ('getBounce', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'bounce': ['*']},
                                         'types': {'bounce': 'float'}}],
                          'setCollisionFlags': [{'argInfo': {'edgeToEdge': {'doc': 'whether to calculate edge - edge collisions ',
                                                                            'type': 'bool'},
                                                             'faceToFace': {'doc': 'whether to calculate face - face collisions',
                                                                            'type': 'bool'},
                                                             'vertToVert': {'doc': 'whether to calculate vertex - vertex collisions ',
                                                                            'type': 'bool'}},
                                                 'args': [('vertToVert',
                                                           'bool',
                                                           'in'),
                                                          ('edgeToEdge',
                                                           'bool',
                                                           'in'),
                                                          ('faceToFace',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {'edgeToEdge': False,
                                                              'faceToFace': False},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets how (or if) this object will collide with other objects.',
                                                 'inArgs': ['vertToVert',
                                                            'edgeToEdge',
                                                            'faceToFace'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'edgeToEdge': ['const'],
                                                                    'faceToFace': ['const'],
                                                                    'vertToVert': ['const']},
                                                 'types': {'edgeToEdge': 'bool',
                                                           'faceToFace': 'bool',
                                                           'vertToVert': 'bool'}}],
                          'setComputeRestAngles': [{'argInfo': {'b': {'doc': 'whether to compute rest angles',
                                                                      'type': 'bool'}},
                                                    'args': [('b',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets whether rest angles will be automatically computed, or overridden manually. If this is set to false, then you must call  setBendRestAngleFromPositions()  to set the rest lengths.',
                                                    'inArgs': ['b'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'b': ['const']},
                                                    'types': {'b': 'bool'}}],
                          'setComputeRestLength': [{'argInfo': {'b': {'doc': 'whether to compute rest lengths',
                                                                      'type': 'bool'}},
                                                    'args': [('b',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSets whether rest lengths will be automatically computed, or overridden manually. If this is set to false, then you must call  setLinksRestLengthFromPositions()  to set the rest lengths.',
                                                    'inArgs': ['b'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'b': ['const']},
                                                    'types': {'b': 'bool'}}],
                          'setDamping': [{'argInfo': {'damping': {'doc': 'the damping value to set',
                                                                  'type': 'float'}},
                                          'args': [('damping',
                                                    'float',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nsets the damping for every point in this mesh',
                                          'inArgs': ['damping'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'damping': []},
                                          'types': {'damping': 'float'}},
                                         {'argInfo': {'damping': {'doc': 'the damping value to set',
                                                                  'type': 'float'}},
                                          'args': [('damping',
                                                    'float',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': '\r\nsets the on a per point basis in this mesh',
                                          'inArgs': ['damping'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'damping': ['*']},
                                          'types': {'damping': 'float'}}],
                          'setDisableGravity': [{'argInfo': {'b': {'doc': 'whether to calculate gravity',
                                                                   'type': 'bool'}},
                                                 'args': [('b',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets whether gravity will affect this object',
                                                 'inArgs': ['b'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'b': ['const']},
                                                 'types': {'b': 'bool'}}],
                          'setDragAndLift': [{'argInfo': {'drag': {'doc': 'value of drag ',
                                                                   'type': 'float'},
                                                          'lift': {'doc': 'value of lift',
                                                                   'type': 'float'}},
                                              'args': [('drag',
                                                        'float',
                                                        'in'),
                                                       ('lift',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nSets the drag and lift values for the cloth',
                                              'inArgs': ['drag', 'lift'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'drag': [],
                                                                 'lift': []},
                                              'types': {'drag': 'float',
                                                        'lift': 'float'}}],
                          'setFriction': [{'argInfo': {'friction': {'doc': 'the friction to set',
                                                                    'type': 'float'}},
                                           'args': [('friction',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nsets the friction for every point in this mesh',
                                           'inArgs': ['friction'],
                                           'inverse': ('getFriction',
                                                       True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'friction': []},
                                           'types': {'friction': 'float'}},
                                          {'argInfo': {'friction': {'doc': 'the friction to set',
                                                                    'type': 'float'}},
                                           'args': [('friction',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nsets the friction on a per point basis for this mesh',
                                           'inArgs': ['friction'],
                                           'inverse': ('getFriction',
                                                       True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'friction': ['*']},
                                           'types': {'friction': 'float'}}],
                          'setIncompressibility': [{'argInfo': {'v': {'doc': 'how incompressible the cloth is',
                                                                      'type': 'float'}},
                                                    'args': [('v',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nWhen the volume tracking pressure model is used this defines how incompressible the internal volume of fluid is. This also will affect how much force is applied to the cloth when air is pumped in. In the case of a balloon higher values of incompressibility will overcome higher stretch resistance. Note that higher incompressibility may require more calculation time.',
                                                    'inArgs': ['v'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'v': []},
                                                    'types': {'v': 'float'}}],
                          'setInputMeshAttractAndRigidStrength': [{'argInfo': {'deformArray': {'doc': 'values for deformability',
                                                                                               'type': 'float'},
                                                                               'inputAttractArray': {'doc': 'values for the input mesh attract ',
                                                                                                     'type': 'float'},
                                                                               'rigidArray': {'doc': 'values for rigidity ',
                                                                                              'type': 'float'}},
                                                                   'args': [('inputAttractArray',
                                                                             'float',
                                                                             'in'),
                                                                            ('rigidArray',
                                                                             'float',
                                                                             'in'),
                                                                            ('deformArray',
                                                                             'float',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': '\r\nSets on a per particle basis, the amount by which each particle is affected by the input mesh attract, rigidity, and deformability. High values for the input mesh attract will make points stick closely to the input mesh. High values for the rigidArray will make the object behave like a rigid body.',
                                                                   'inArgs': ['inputAttractArray',
                                                                              'rigidArray',
                                                                              'deformArray'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'deformArray': ['*'],
                                                                                      'inputAttractArray': ['*'],
                                                                                      'rigidArray': ['*']},
                                                                   'types': {'deformArray': 'float',
                                                                             'inputAttractArray': 'float',
                                                                             'rigidArray': 'float'}}],
                          'setInputMeshAttractDamping': [{'argInfo': {'damping': {'doc': 'the damping value',
                                                                                  'type': 'float'}},
                                                          'args': [('damping',
                                                                    'float',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': '\r\nDefines how springy the effect of Input Mesh Attract is. At a value of zero input mesh attract will behave like a spring connection from the input mesh to the output dynamic mesh. The cloth will tend to wiggle about the input mesh position. As the Input Attract Damp is increased to 1 the cloth mesh will still move to the input mesh position but not have the momentum to travel past it, so will no longer occillate about the input position.',
                                                          'inArgs': ['damping'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'damping': []},
                                                          'types': {'damping': 'float'}}],
                          'setInputMeshAttractPositions': [{'argInfo': {'positions': {'doc': 'the array containing the position information',
                                                                                      'type': 'MFloatPointArray'}},
                                                            'args': [('positions',
                                                                      'MFloatPointArray',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': '\r\nSets the positions for input mesh attract',
                                                            'inArgs': ['positions'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'positions': ['const',
                                                                                             '&']},
                                                            'types': {'positions': 'MFloatPointArray'}}],
                          'setInverseMass': [{'argInfo': {'invMass': {'doc': 'the inverse of the mass. A value of 0 means an infinitely heave object.',
                                                                      'type': 'float'}},
                                              'args': [('invMass',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nsets the mass for every point in this mesh',
                                              'inArgs': ['invMass'],
                                              'inverse': ('getInverseMass',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'invMass': []},
                                              'types': {'invMass': 'float'}},
                                             {'argInfo': {'invMass': {'doc': 'the inverse of the mass. A value of 0 means an infinitely heave object.',
                                                                      'type': 'float'}},
                                              'args': [('invMass',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\r\nsets the mass on a per point basis in this mesh',
                                              'inArgs': ['invMass'],
                                              'inverse': ('getInverseMass',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'invMass': ['*']},
                                              'types': {'invMass': 'float'}}],
                          'setLinksRestLengthFromPositions': [{'argInfo': {'positions': {'doc': 'the array containing the position information',
                                                                                         'type': 'MFloatPointArray'}},
                                                               'args': [('positions',
                                                                         'MFloatPointArray',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': '\r\nSets the the rest length from the list of positions for the underlying N Object. This sets the shape that the stretch/compression resistance are trying to achieve.',
                                                               'inArgs': ['positions'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'positions': ['const',
                                                                                                '&']},
                                                               'types': {'positions': 'MFloatPointArray'}}],
                          'setMaxIterations': [{'argInfo': {'it': {'doc': 'number of iterations',
                                                                   'type': 'int'}},
                                                'args': [('it',
                                                          'int',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nSets the number of iterations the solver will perform on various dynamic properties like drag, damping, stretch and bend. Higher iterations take longer, and the primary use of this attribute is to keep things from locking up should high iteration values be requested.',
                                                'inArgs': ['it'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'it': ['const']},
                                                'types': {'it': 'int'}}],
                          'setMaxSelfCollisionIterations': [{'argInfo': {'it': {'doc': 'number of iterations',
                                                                                'type': 'int'}},
                                                             'args': [('it',
                                                                       'int',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': '\r\nSets the number of iterations the solver will perform for self collisions on this object.',
                                                             'inArgs': ['it'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'it': ['const']},
                                                             'types': {'it': 'int'}}],
                          'setPositions': [{'argInfo': {'positions': {'doc': 'the array containing the position information ',
                                                                      'type': 'MFloatPointArray'},
                                                        'startFrame': {'doc': 'whether this information represents the state of the object at the start frame.',
                                                                       'type': 'bool'}},
                                            'args': [('positions',
                                                      'MFloatPointArray',
                                                      'in'),
                                                     ('startFrame',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'startFrame': True},
                                            'deprecated': False,
                                            'doc': '\r\nSets the positions of the vertices of the underlying N cloth object',
                                            'inArgs': ['positions',
                                                       'startFrame'],
                                            'inverse': ('getPositions',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'positions': ['const',
                                                                             '&'],
                                                               'startFrame': []},
                                            'types': {'positions': 'MFloatPointArray',
                                                      'startFrame': 'bool'}}],
                          'setPressure': [{'argInfo': {'pressure': {'doc': 'the value of pressure to set',
                                                                    'type': 'float'}},
                                           'args': [('pressure',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nSets the pressure within the cloth. This defines a force applied along the surface normal direction',
                                           'inArgs': ['pressure'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'pressure': []},
                                           'types': {'pressure': 'float'}}],
                          'setPressureDamping': [{'argInfo': {'damp': {'doc': 'value to set',
                                                                       'type': 'float'}},
                                                  'args': [('damp',
                                                            'float',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets the damping value for pressure',
                                                  'inArgs': ['damp'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'damp': []},
                                                  'types': {'damp': 'float'}}],
                          'setPumpRate': [{'argInfo': {'pump': {'doc': 'value to set',
                                                                'type': 'float'}},
                                           'args': [('pump',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nDefines the rate at which air pressure is added to the object',
                                           'inArgs': ['pump'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'pump': []},
                                           'types': {'pump': 'float'}}],
                          'setRestitutionAngle': [{'argInfo': {'angle': {'doc': 'value to set',
                                                                         'type': 'float'}},
                                                   'args': [('angle',
                                                             'float',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nDefines how far we can bend across an edge before it will fail to go back to the rest angle when there are no forces acting on the cloth.',
                                                   'inArgs': ['angle'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'angle': []},
                                                   'types': {'angle': 'float'}}],
                          'setRestitutionTension': [{'argInfo': {'tension': {'doc': 'value to set',
                                                                             'type': 'float'}},
                                                     'args': [('tension',
                                                               'float',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '\r\nHow far can the links be stretched before they fail to go back to their rest length when there are no forces acting on the cloth. When the tension is greater than the defined value the defined rest length will increase until the tension is equal this value. For very low values the material will pull apart like taffy, yet still resist stretching under mild forces.',
                                                     'inArgs': ['tension'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'tension': []},
                                                     'types': {'tension': 'float'}}],
                          'setSealHoles': [{'argInfo': {'seal': {'doc': 'whether to seal holes',
                                                                 'type': 'bool'}},
                                            'args': [('seal',
                                                      'bool',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nWhen the volume tracking pressure method is used this determines if physical holes in the cloth model are treated as being capped or not. If holes are not sealed, then air can escape out them, which also has the effect of pushing the cloth. For example, this can simulate a rubber balloon that is suddenly released. It also allows for inflow based on motion of the cloth. The opening in a parachute will allow air to flow in as it falls down, causing sideways pressure that inflates it. Note that drag alone cannot achieve this sort of effect',
                                            'inArgs': ['seal'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'seal': []},
                                            'types': {'seal': 'bool'}}],
                          'setSelfCollideWidth': [{'argInfo': {'width': {'doc': 'value to set',
                                                                         'type': 'float'}},
                                                   'args': [('width',
                                                             'float',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nSets the self collision width',
                                                   'inArgs': ['width'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'width': []},
                                                   'types': {'width': 'float'}}],
                          'setSelfCollisionFlags': [{'argInfo': {'edgeToEdge': {'doc': 'whether to calculate edge - edge collisions ',
                                                                                'type': 'bool'},
                                                                 'edgeToFace': {'doc': 'whether to calculate edge - face collisions',
                                                                                'type': 'bool'},
                                                                 'vertToEdge': {'doc': 'whether to calculate vertex - edge collisions ',
                                                                                'type': 'bool'},
                                                                 'vertToFace': {'doc': 'whether to calculate vertex - face collisions ',
                                                                                'type': 'bool'},
                                                                 'vertToVert': {'doc': 'whether to calculate vertex - vertex collisions ',
                                                                                'type': 'bool'}},
                                                     'args': [('vertToVert',
                                                               'bool',
                                                               'in'),
                                                              ('vertToEdge',
                                                               'bool',
                                                               'in'),
                                                              ('vertToFace',
                                                               'bool',
                                                               'in'),
                                                              ('edgeToEdge',
                                                               'bool',
                                                               'in'),
                                                              ('edgeToFace',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {'edgeToEdge': False,
                                                                  'edgeToFace': False,
                                                                  'vertToEdge': False,
                                                                  'vertToFace': False},
                                                     'deprecated': False,
                                                     'doc': '\r\nSets how (or if) this object will collide with itself.',
                                                     'inArgs': ['vertToVert',
                                                                'vertToEdge',
                                                                'vertToFace',
                                                                'edgeToEdge',
                                                                'edgeToFace'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'edgeToEdge': ['const'],
                                                                        'edgeToFace': ['const'],
                                                                        'vertToEdge': ['const'],
                                                                        'vertToFace': ['const'],
                                                                        'vertToVert': ['const']},
                                                     'types': {'edgeToEdge': 'bool',
                                                               'edgeToFace': 'bool',
                                                               'vertToEdge': 'bool',
                                                               'vertToFace': 'bool',
                                                               'vertToVert': 'bool'}}],
                          'setSelfCollisionSoftness': [{'argInfo': {'softness': {'doc': 'value to set.',
                                                                                 'type': 'float'}},
                                                        'args': [('softness',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': '\r\nThis allows one to lower the repulsive force of self collisions such that some interpenetration within the collide width is allowed. This can in some cases reduce jitter due to self collision with low selfCollideIterations. In general its use should be avoided, however.',
                                                        'inArgs': ['softness'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'softness': []},
                                                        'types': {'softness': 'float'}}],
                          'setSelfCrossoverPush': [{'argInfo': {'val': {'doc': 'value for crossover push',
                                                                        'type': 'float'}},
                                                    'args': [('val',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\r\nSee node documentation.',
                                                    'inArgs': ['val'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'val': []},
                                                    'types': {'val': 'float'}}],
                          'setSelfTrappedCheck': [{'argInfo': {'on': {'doc': 'whether to turn on self trapped check.',
                                                                      'type': 'bool'}},
                                                   'args': [('on',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\r\nThis tracks self collision crossovers and attempts to push the crossed over points back. It assumes that the surface is in a good state at the start and attempts to preserve that relative state. It is useful in cases where cloth can get caught between passive objects than interpenetrate (for example an elbow passing through a chest). Rather than get stuck on the wrong side this allows the cloth to push back to the correct side when the passive objects later separate.',
                                                   'inArgs': ['on'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'on': []},
                                                   'types': {'on': 'bool'}}],
                          'setShearResistance': [{'argInfo': {'resistance': {'doc': 'value to set',
                                                                             'type': 'float'}},
                                                  'args': [('resistance',
                                                            'float',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\r\nSets the shear resistance. Shear can be thought of as the bend in the plane of the cloth.',
                                                  'inArgs': ['resistance'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'resistance': []},
                                                  'types': {'resistance': 'float'}}],
                          'setStartPressure': [{'argInfo': {'startPressure': {'doc': 'the start pressure',
                                                                              'type': 'float'}},
                                                'args': [('startPressure',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\r\nWith the volume tracking pressure method this defines the relative air pressure inside the object at the startframe.',
                                                'inArgs': ['startPressure'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'startPressure': []},
                                                'types': {'startPressure': 'float'}}],
                          'setStretchAndCompressionResistance': [{'argInfo': {'compressionResist': {'doc': 'value to set for compression',
                                                                                                    'type': 'float'},
                                                                              'stretchResist': {'doc': 'value to set for stretch ',
                                                                                                'type': 'float'}},
                                                                  'args': [('stretchResist',
                                                                            'float',
                                                                            'in'),
                                                                           ('compressionResist',
                                                                            'float',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nStretch Resistance:',
                                                                  'inArgs': ['stretchResist',
                                                                             'compressionResist'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'compressionResist': [],
                                                                                     'stretchResist': []},
                                                                  'types': {'compressionResist': 'float',
                                                                            'stretchResist': 'float'}},
                                                                 {'argInfo': {'compressionResist': {'doc': 'value to set for compression',
                                                                                                    'type': 'float'},
                                                                              'stretchResist': {'doc': 'value to set for stretch ',
                                                                                                'type': 'float'}},
                                                                  'args': [('stretchResist',
                                                                            'float',
                                                                            'in'),
                                                                           ('compressionResist',
                                                                            'float',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': '\r\nSets the stretch and compression resistance for the mesh on a per vertex basis',
                                                                  'inArgs': ['stretchResist',
                                                                             'compressionResist'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'compressionResist': ['*'],
                                                                                     'stretchResist': ['*']},
                                                                  'types': {'compressionResist': 'float',
                                                                            'stretchResist': 'float'}}],
                          'setTangentialDrag': [{'argInfo': {'tangentialDrag': {'doc': 'the tangential drag',
                                                                                'type': 'float'}},
                                                 'args': [('tangentialDrag',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\r\nSets the tangential drag values for the cloth. Defines the component of drag tangent to the surface. With a value of zero a flat plane will slice through air with no resistance and only have drag when moving along its normal axis. With a value of 1.0 the effect of drag will be equal in all directions.',
                                                 'inArgs': ['tangentialDrag'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'tangentialDrag': []},
                                                 'types': {'tangentialDrag': 'float'}}],
                          'setThickness': [{'argInfo': {'radius': {'doc': 'the radius to set',
                                                                   'type': 'float'}},
                                            'args': [('radius',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nsets a radius on each point of the mesh for collision purposes. The bigger the radius/thickness, the more easily things collide.',
                                            'inArgs': ['radius'],
                                            'inverse': ('getThickness',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'radius': []},
                                            'types': {'radius': 'float'}},
                                           {'argInfo': {'radius': {'doc': 'the radius to set',
                                                                   'type': 'float'}},
                                            'args': [('radius',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\r\nsets a radius (thickness) on a per point basis for the mesh for collision purposes. The bigger the radius, the more easily things collide.',
                                            'inArgs': ['radius'],
                                            'inverse': ('getThickness',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'radius': ['*']},
                                            'types': {'radius': 'float'}}],
                          'setTopology': [{'argInfo': {'edges': {'doc': 'an array containing the edge description. Each element is a vertex index.',
                                                                 'type': 'int'},
                                                       'faces': {'doc': 'an array containing the actual face description. Each element is a vertex index. ',
                                                                 'type': 'int'},
                                                       'numEdges': {'doc': 'number of edges ',
                                                                    'type': 'int'},
                                                       'numFaces': {'doc': 'number of faces ',
                                                                    'type': 'int'},
                                                       'numVertsPerFace': {'doc': 'an array of size numFaces, where each element describes the number of verts on that face ',
                                                                           'type': 'int'}},
                                           'args': [('numFaces',
                                                     'int',
                                                     'in'),
                                                    ('numVertsPerFace',
                                                     'int',
                                                     'in'),
                                                    ('faces',
                                                     'int',
                                                     'in'),
                                                    ('numEdges',
                                                     'int',
                                                     'in'),
                                                    ('edges',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\r\nsets the topology of the underlying N Object. Before calling other methods, this must be the first method you call once the cloth object is created.',
                                           'inArgs': ['numFaces',
                                                      'numVertsPerFace',
                                                      'faces',
                                                      'numEdges',
                                                      'edges'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'edges': ['*'],
                                                              'faces': ['*'],
                                                              'numEdges': ['const'],
                                                              'numFaces': ['const'],
                                                              'numVertsPerFace': ['*']},
                                           'types': {'edges': 'int',
                                                     'faces': 'int',
                                                     'numEdges': 'int',
                                                     'numFaces': 'int',
                                                     'numVertsPerFace': 'int'}}],
                          'setTrackVolume': [{'argInfo': {'track': {'doc': 'whether to track volume',
                                                                    'type': 'bool'}},
                                              'args': [('track',
                                                        'bool',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\n Parameters: \n \n [in]  track  whether to track volume \n \n \n Returns: \n MS::kSuccess  the operation was completed successfully  \n MS::kFailure  the operation failed  \n \n \n',
                                              'inArgs': ['track'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'track': []},
                                              'types': {'track': 'bool'}}],
                          'setVelocities': [{'argInfo': {'velocities': {'doc': 'the array containing the velocity information',
                                                                        'type': 'MFloatPointArray'}},
                                             'args': [('velocities',
                                                       'MFloatPointArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\r\nSets the velocities of the vertices of the underlying Ncloth object',
                                             'inArgs': ['velocities'],
                                             'inverse': ('getVelocities',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'velocities': ['const',
                                                                               '&']},
                                             'types': {'velocities': 'MFloatPointArray'}}]},
              'pymelEnums': {}},
  'MnObject': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MnParticle': {'enums': {},
                 'invertibles': [('setThickness', 'getThickness'),
                                 ('setInverseMass', 'getInverseMass'),
                                 ('setVelocities', 'getVelocities'),
                                 ('setPositions', 'getPositions'),
                                 ('setBounce', 'getBounce'),
                                 ('setFriction', 'getFriction')],
                 'methods': {'createNParticle': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '\nCreates the underlying Maya TnParticle and sets this class to wrap it.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                             'getBounce': [{'argInfo': {'bounce': {'doc': 'the array will be filled with the bounce.',
                                                                   'type': 'MFloatArray'}},
                                            'args': [('bounce',
                                                      'MFloatArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\ngets the Bounce of the points of the underlying N particle object.',
                                            'inArgs': [],
                                            'inverse': ('setBounce',
                                                        False),
                                            'outArgs': ['bounce'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'bounce': ['&']},
                                            'types': {'bounce': 'MFloatArray'}}],
                             'getFriction': [{'argInfo': {'friction': {'doc': 'the array will be filled with the friction.',
                                                                       'type': 'MFloatArray'}},
                                              'args': [('friction',
                                                        'MFloatArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\ngets the friction of the points of the underlying N particle object.',
                                              'inArgs': [],
                                              'inverse': ('setFriction',
                                                          False),
                                              'outArgs': ['friction'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'friction': ['&']},
                                              'types': {'friction': 'MFloatArray'}}],
                             'getInverseMass': [{'argInfo': {'inverseMass': {'doc': 'the array will be filled with the inverse masses.',
                                                                             'type': 'MFloatArray'}},
                                                 'args': [('inverseMass',
                                                           'MFloatArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\ngets the inverseMass of the points of the underlying N particle object.',
                                                 'inArgs': [],
                                                 'inverse': ('setInverseMass',
                                                             False),
                                                 'outArgs': ['inverseMass'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'inverseMass': ['&']},
                                                 'types': {'inverseMass': 'MFloatArray'}}],
                             'getNumVertices': [{'argInfo': {'numVerts': {'doc': 'Number of vertices.',
                                                                          'type': 'uint'}},
                                                 'args': [('numVerts',
                                                           'uint',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nReturns the number of vertices in the underlying nParticle',
                                                 'inArgs': [],
                                                 'outArgs': ['numVerts'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'numVerts': ['unsigned',
                                                                                 '&']},
                                                 'types': {'numVerts': 'uint'}}],
                             'getPositions': [{'argInfo': {'positions': {'doc': 'the array will be filled with the positions.',
                                                                         'type': 'MFloatPointArray'}},
                                               'args': [('positions',
                                                         'MFloatPointArray',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\ngets the positions of the points of the underlying N Object.',
                                               'inArgs': [],
                                               'inverse': ('setPositions',
                                                           False),
                                               'outArgs': ['positions'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'positions': ['&']},
                                               'types': {'positions': 'MFloatPointArray'}}],
                             'getThickness': [{'argInfo': {'radius': {'doc': 'the array will be filled with the radii.',
                                                                      'type': 'MFloatArray'}},
                                               'args': [('radius',
                                                         'MFloatArray',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\ngets the radii of the points of the underlying N particle object.',
                                               'inArgs': [],
                                               'inverse': ('setThickness',
                                                           False),
                                               'outArgs': ['radius'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'radius': ['&']},
                                               'types': {'radius': 'MFloatArray'}}],
                             'getVelocities': [{'argInfo': {'velocities': {'doc': 'the array will be filled with the positions.',
                                                                           'type': 'MFloatPointArray'}},
                                                'args': [('velocities',
                                                          'MFloatPointArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\ngets the velocities of the points of the underlying nParticle object.',
                                                'inArgs': [],
                                                'inverse': ('setVelocities',
                                                            False),
                                                'outArgs': ['velocities'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'velocities': ['&']},
                                                'types': {'velocities': 'MFloatPointArray'}}],
                             'setBounce': [{'argInfo': {'bounce': {'doc': 'value of bounce to set',
                                                                   'type': 'float'}},
                                            'args': [('bounce',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nsets the bounce for every particle',
                                            'inArgs': ['bounce'],
                                            'inverse': ('getBounce',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'bounce': []},
                                            'types': {'bounce': 'float'}},
                                           {'argInfo': {'bounce': {'doc': 'value of bounce to set',
                                                                   'type': 'float'}},
                                            'args': [('bounce',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nsets the bounce on a per point basis for these particles',
                                            'inArgs': ['bounce'],
                                            'inverse': ('getBounce',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'bounce': ['*']},
                                            'types': {'bounce': 'float'}}],
                             'setCollide': [{'argInfo': {'b': {'doc': 'whether to calculate collision',
                                                               'type': 'bool'}},
                                             'args': [('b',
                                                       'bool',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSets whether collisions will affect this object',
                                             'inArgs': ['b'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'b': ['const']},
                                             'types': {'b': 'bool'}}],
                             'setDamping': [{'argInfo': {'damping': {'doc': 'the damping value to set',
                                                                     'type': 'float'}},
                                             'args': [('damping',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nsets the damping for every particle',
                                             'inArgs': ['damping'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'damping': []},
                                             'types': {'damping': 'float'}},
                                            {'argInfo': {'damping': {'doc': 'the damping value to set',
                                                                     'type': 'float'}},
                                             'args': [('damping',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nsets the damping on a per point basis for these particles',
                                             'inArgs': ['damping'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'damping': ['*']},
                                             'types': {'damping': 'float'}}],
                             'setDisableGravity': [{'argInfo': {'b': {'doc': 'whether to calculate gravity',
                                                                      'type': 'bool'}},
                                                    'args': [('b',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nSets whether gravity will affect this object',
                                                    'inArgs': ['b'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'b': ['const']},
                                                    'types': {'b': 'bool'}}],
                             'setDragAndLift': [{'argInfo': {'drag': {'doc': 'value of drag ',
                                                                      'type': 'float'},
                                                             'lift': {'doc': 'value of lift',
                                                                      'type': 'float'}},
                                                 'args': [('drag',
                                                           'float',
                                                           'in'),
                                                          ('lift',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSets the drag and lift values for the nParticle',
                                                 'inArgs': ['drag',
                                                            'lift'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'drag': [],
                                                                    'lift': []},
                                                 'types': {'drag': 'float',
                                                           'lift': 'float'}}],
                             'setFriction': [{'argInfo': {'friction': {'doc': 'the friction to set',
                                                                       'type': 'float'}},
                                              'args': [('friction',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nsets the friction for every particle',
                                              'inArgs': ['friction'],
                                              'inverse': ('getFriction',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'friction': []},
                                              'types': {'friction': 'float'}},
                                             {'argInfo': {'friction': {'doc': 'the friction to set',
                                                                       'type': 'float'}},
                                              'args': [('friction',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nsets the friction on a per point basis for these particles',
                                              'inArgs': ['friction'],
                                              'inverse': ('getFriction',
                                                          True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'friction': ['*']},
                                              'types': {'friction': 'float'}}],
                             'setIncompressibility': [{'argInfo': {'incompressibility': {'doc': 'the incompressibility value to set',
                                                                                         'type': 'float'}},
                                                       'args': [('incompressibility',
                                                                 'float',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nsets the incompressibility',
                                                       'inArgs': ['incompressibility'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'incompressibility': []},
                                                       'types': {'incompressibility': 'float'}}],
                             'setInverseMass': [{'argInfo': {'invMass': {'doc': 'the inverse of the mass. A value of 0 means an infinitely heavy object.',
                                                                         'type': 'float'}},
                                                 'args': [('invMass',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nsets the mass for every particle',
                                                 'inArgs': ['invMass'],
                                                 'inverse': ('getInverseMass',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'invMass': []},
                                                 'types': {'invMass': 'float'}},
                                                {'argInfo': {'invMass': {'doc': 'the inverse of the mass. A value of 0 means an infinitely heave object.',
                                                                         'type': 'float'}},
                                                 'args': [('invMass',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nsets the mass on a per point basis',
                                                 'inArgs': ['invMass'],
                                                 'inverse': ('getInverseMass',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'invMass': ['*']},
                                                 'types': {'invMass': 'float'}}],
                             'setLiquidRadiusScale': [{'argInfo': {'liquidRadiusScale': {'doc': 'the liquidRadiusScale value to set',
                                                                                         'type': 'float'}},
                                                       'args': [('liquidRadiusScale',
                                                                 'float',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '\nsets the liquidRadiusScale for every particle',
                                                       'inArgs': ['liquidRadiusScale'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'liquidRadiusScale': []},
                                                       'types': {'liquidRadiusScale': 'float'}}],
                             'setLiquidSimulation': [{'argInfo': {'b': {'doc': 'whether to calculate liquid',
                                                                        'type': 'bool'}},
                                                      'args': [('b',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets whether this object will solve as a liquid',
                                                      'inArgs': ['b'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'b': ['const']},
                                                      'types': {'b': 'bool'}}],
                             'setMaxIterations': [{'argInfo': {'it': {'doc': 'number of iterations',
                                                                      'type': 'int'}},
                                                   'args': [('it',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '\nSets the number of iterations the solver will perform on various dynamic properties like drag, damping, stretch and bend. Higher iterations take longer, and the primary use of this attribute is to keep things from locking up should high iteration values be requested.',
                                                   'inArgs': ['it'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'it': ['const']},
                                                   'types': {'it': 'int'}}],
                             'setMaxSelfCollisionIterations': [{'argInfo': {'it': {'doc': 'number of iterations',
                                                                                   'type': 'int'}},
                                                                'args': [('it',
                                                                          'int',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': '\nSets the number of iterations the solver will perform for self collisions on this object.',
                                                                'inArgs': ['it'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {'it': ['const']},
                                                                'types': {'it': 'int'}}],
                             'setPositions': [{'argInfo': {'positions': {'doc': 'the array containing the position information ',
                                                                         'type': 'MFloatPointArray'},
                                                           'startFrame': {'doc': 'whether this information represents the state of the object at the start frame.',
                                                                          'type': 'bool'}},
                                               'args': [('positions',
                                                         'MFloatPointArray',
                                                         'in'),
                                                        ('startFrame',
                                                         'bool',
                                                         'in')],
                                               'defaults': {'startFrame': True},
                                               'deprecated': False,
                                               'doc': '\nSets the positions of the vertices of the underlying nParticle object',
                                               'inArgs': ['positions',
                                                          'startFrame'],
                                               'inverse': ('getPositions',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'positions': ['const',
                                                                                '&'],
                                                                  'startFrame': []},
                                               'types': {'positions': 'MFloatPointArray',
                                                         'startFrame': 'bool'}}],
                             'setRestDensity': [{'argInfo': {'restDensity': {'doc': 'the rest density value to set',
                                                                             'type': 'float'}},
                                                 'args': [('restDensity',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nsets the rest density for every particle',
                                                 'inArgs': ['restDensity'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'restDensity': []},
                                                 'types': {'restDensity': 'float'}}],
                             'setSelfCollide': [{'argInfo': {'b': {'doc': 'whether to calculate self collision',
                                                                   'type': 'bool'}},
                                                 'args': [('b',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSets whether self collisions will affect this object',
                                                 'inArgs': ['b'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'b': ['const']},
                                                 'types': {'b': 'bool'}}],
                             'setSelfCollideWidth': [{'argInfo': {'width': {'doc': 'value to set',
                                                                            'type': 'float'}},
                                                      'args': [('width',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets the self collision width',
                                                      'inArgs': ['width'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'width': []},
                                                      'types': {'width': 'float'}}],
                             'setSelfCollisionSoftness': [{'argInfo': {'softness': {'doc': 'value to set.',
                                                                                    'type': 'float'}},
                                                           'args': [('softness',
                                                                     'float',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '\nThis allows one to lower the repulsive force of self collisions such that some interpenetration within the collide width is allowed. This can in some cases reduce jitter due to self collision with low selfCollideIterations. In general its use should be avoided, however.',
                                                           'inArgs': ['softness'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'softness': []},
                                                           'types': {'softness': 'float'}}],
                             'setSurfaceTension': [{'argInfo': {'surfaceTension': {'doc': 'the surfaceTension value to set',
                                                                                   'type': 'float'}},
                                                    'args': [('surfaceTension',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nsets the surfaceTension for every particle',
                                                    'inArgs': ['surfaceTension'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'surfaceTension': []},
                                                    'types': {'surfaceTension': 'float'}},
                                                   {'argInfo': {'surfaceTension': {'doc': 'the surfaceTension value to set',
                                                                                   'type': 'float'}},
                                                    'args': [('surfaceTension',
                                                              'float',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nsets the surfaceTension on a per point basis for these particles',
                                                    'inArgs': ['surfaceTension'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'surfaceTension': ['*']},
                                                    'types': {'surfaceTension': 'float'}}],
                             'setThickness': [{'argInfo': {'radius': {'doc': 'the radius to set',
                                                                      'type': 'float'}},
                                               'args': [('radius',
                                                         'float',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nsets a radius on each point collision purposes. The bigger the radius/thickness, the more easily things collide.',
                                               'inArgs': ['radius'],
                                               'inverse': ('getThickness',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'radius': []},
                                               'types': {'radius': 'float'}},
                                              {'argInfo': {'radius': {'doc': 'the radius to set',
                                                                      'type': 'float'}},
                                               'args': [('radius',
                                                         'float',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nsets a radius (thickness) on a per point basis for collision purposes. The bigger the radius, the more easily things collide.',
                                               'inArgs': ['radius'],
                                               'inverse': ('getThickness',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'radius': ['*']},
                                               'types': {'radius': 'float'}}],
                             'setTopology': [{'argInfo': {'numPoints': {'doc': 'number of particles',
                                                                        'type': 'int'}},
                                              'args': [('numPoints',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSets the topology of the underlying N Object. This must be called whenever the number of particles changes, before setting any particle properties',
                                              'inArgs': ['numPoints'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'numPoints': ['const']},
                                              'types': {'numPoints': 'int'}}],
                             'setVelocities': [{'argInfo': {'velocities': {'doc': 'the array containing the velocity information',
                                                                           'type': 'MFloatPointArray'}},
                                                'args': [('velocities',
                                                          'MFloatPointArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': '\nSets the velocities of the vertices of the underlying nParticle object',
                                                'inArgs': ['velocities'],
                                                'inverse': ('getVelocities',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'velocities': ['const',
                                                                                  '&']},
                                                'types': {'velocities': 'MFloatPointArray'}}],
                             'setViscosity': [{'argInfo': {'viscosity': {'doc': 'the viscosity value to set',
                                                                         'type': 'float'}},
                                               'args': [('viscosity',
                                                         'float',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nsets the viscosity for every particle',
                                               'inArgs': ['viscosity'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'viscosity': []},
                                               'types': {'viscosity': 'float'}},
                                              {'argInfo': {'viscosity': {'doc': 'the viscosity value to set',
                                                                         'type': 'float'}},
                                               'args': [('viscosity',
                                                         'float',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nsets the viscosity on a per point basis for these particles',
                                               'inArgs': ['viscosity'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'viscosity': ['*']},
                                               'types': {'viscosity': 'float'}}]},
                 'pymelEnums': {}},
  'MnRigid': {'enums': {},
              'invertibles': [('setBounce', 'getBounce'),
                              ('setPositions', 'getPositions'),
                              ('setThickness', 'getThickness'),
                              ('setVelocities', 'getVelocities'),
                              ('setFriction', 'getFriction')],
              'methods': {'createNRigid': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nCreates the underlying Maya TnRigid and sets this class to wrap it.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                          'getBounce': [{'argInfo': {'bounce': {'doc': 'the array will be filled with the bounce.',
                                                                'type': 'MFloatArray'}},
                                         'args': [('bounce',
                                                   'MFloatArray',
                                                   'out')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\ngets the bounce at each point of the underlying N rigid object.',
                                         'inArgs': [],
                                         'inverse': ('setBounce', False),
                                         'outArgs': ['bounce'],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'bounce': ['&']},
                                         'types': {'bounce': 'MFloatArray'}}],
                          'getFriction': [{'argInfo': {'friction': {'doc': 'the array will be filled with the friction.',
                                                                    'type': 'MFloatArray'}},
                                           'args': [('friction',
                                                     'MFloatArray',
                                                     'out')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\ngets the friction at each point of the underlying N rigid object.',
                                           'inArgs': [],
                                           'inverse': ('setFriction',
                                                       False),
                                           'outArgs': ['friction'],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'friction': ['&']},
                                           'types': {'friction': 'MFloatArray'}}],
                          'getInverseMass': [{'argInfo': {'inverseMass': {'doc': 'the array will be filled with the inverse masses.',
                                                                          'type': 'MFloatArray'}},
                                              'args': [('inverseMass',
                                                        'MFloatArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\ngets the inverseMass at each point of the underlying N rigid object.',
                                              'inArgs': [],
                                              'outArgs': ['inverseMass'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'inverseMass': ['&']},
                                              'types': {'inverseMass': 'MFloatArray'}}],
                          'getNumVertices': [{'argInfo': {'numVerts': {'doc': 'Number of vertices.',
                                                                       'type': 'uint'}},
                                              'args': [('numVerts',
                                                        'uint',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nReturns the number of vertices in the underlying nRigid',
                                              'inArgs': [],
                                              'outArgs': ['numVerts'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'numVerts': ['unsigned',
                                                                              '&']},
                                              'types': {'numVerts': 'uint'}}],
                          'getPositions': [{'argInfo': {'positions': {'doc': 'the array will be filled with the positions.',
                                                                      'type': 'MFloatPointArray'}},
                                            'args': [('positions',
                                                      'MFloatPointArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\ngets the positions of the points of the underlying N Object.',
                                            'inArgs': [],
                                            'inverse': ('setPositions',
                                                        False),
                                            'outArgs': ['positions'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'positions': ['&']},
                                            'types': {'positions': 'MFloatPointArray'}}],
                          'getThickness': [{'argInfo': {'radius': {'doc': 'the array will be filled with the thickness.',
                                                                   'type': 'MFloatArray'}},
                                            'args': [('radius',
                                                      'MFloatArray',
                                                      'out')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\ngets the thickness at each point of the underlying N rigid object.',
                                            'inArgs': [],
                                            'inverse': ('setThickness',
                                                        False),
                                            'outArgs': ['radius'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'radius': ['&']},
                                            'types': {'radius': 'MFloatArray'}}],
                          'getVelocities': [{'argInfo': {'velocities': {'doc': 'the array will be filled with the positions.',
                                                                        'type': 'MFloatPointArray'}},
                                             'args': [('velocities',
                                                       'MFloatPointArray',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\ngets the velocities of the points of the underlying nRigid object.',
                                             'inArgs': [],
                                             'inverse': ('setVelocities',
                                                         False),
                                             'outArgs': ['velocities'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'velocities': ['&']},
                                             'types': {'velocities': 'MFloatPointArray'}}],
                          'setBounce': [{'argInfo': {'bounce': {'doc': 'value of bounce to set',
                                                                'type': 'float'}},
                                         'args': [('bounce',
                                                   'float',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nsets the bounce for every point in this mesh',
                                         'inArgs': ['bounce'],
                                         'inverse': ('getBounce', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'bounce': []},
                                         'types': {'bounce': 'float'}},
                                        {'argInfo': {'bounce': {'doc': 'value of bounce to set',
                                                                'type': 'float'}},
                                         'args': [('bounce',
                                                   'float',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '\nsets the bounce on a per point basis in this mesh',
                                         'inArgs': ['bounce'],
                                         'inverse': ('getBounce', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'bounce': ['*']},
                                         'types': {'bounce': 'float'}}],
                          'setCollisionFlags': [{'argInfo': {'edgeToEdge': {'doc': 'whether to calculate edge - edge collisions ',
                                                                            'type': 'bool'},
                                                             'faceToFace': {'doc': 'whether to calculate face - face collisions',
                                                                            'type': 'bool'},
                                                             'vertToVert': {'doc': 'whether to calculate vertex - vertex collisions ',
                                                                            'type': 'bool'}},
                                                 'args': [('vertToVert',
                                                           'bool',
                                                           'in'),
                                                          ('edgeToEdge',
                                                           'bool',
                                                           'in'),
                                                          ('faceToFace',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {'edgeToEdge': False,
                                                              'faceToFace': False},
                                                 'deprecated': False,
                                                 'doc': '\nSets how (or if) this object will collide with other objects.',
                                                 'inArgs': ['vertToVert',
                                                            'edgeToEdge',
                                                            'faceToFace'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'edgeToEdge': ['const'],
                                                                    'faceToFace': ['const'],
                                                                    'vertToVert': ['const']},
                                                 'types': {'edgeToEdge': 'bool',
                                                           'faceToFace': 'bool',
                                                           'vertToVert': 'bool'}}],
                          'setFriction': [{'argInfo': {'friction': {'doc': 'the friction to set',
                                                                    'type': 'float'}},
                                           'args': [('friction',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nsets the friction for every point in this mesh',
                                           'inArgs': ['friction'],
                                           'inverse': ('getFriction',
                                                       True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'friction': []},
                                           'types': {'friction': 'float'}},
                                          {'argInfo': {'friction': {'doc': 'the friction to set',
                                                                    'type': 'float'}},
                                           'args': [('friction',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nsets the friction on a per point basis for this mesh',
                                           'inArgs': ['friction'],
                                           'inverse': ('getFriction',
                                                       True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'friction': ['*']},
                                           'types': {'friction': 'float'}}],
                          'setPositions': [{'argInfo': {'positions': {'doc': 'the array containing the position information ',
                                                                      'type': 'MFloatPointArray'},
                                                        'startFrame': {'doc': 'whether this information represents the state of the object at the start frame.',
                                                                       'type': 'bool'}},
                                            'args': [('positions',
                                                      'MFloatPointArray',
                                                      'in'),
                                                     ('startFrame',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'startFrame': True},
                                            'deprecated': False,
                                            'doc': '\nSets the positions of the vertices of the underlying nRigid object',
                                            'inArgs': ['positions',
                                                       'startFrame'],
                                            'inverse': ('getPositions',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'positions': ['const',
                                                                             '&'],
                                                               'startFrame': []},
                                            'types': {'positions': 'MFloatPointArray',
                                                      'startFrame': 'bool'}}],
                          'setThickness': [{'argInfo': {'radius': {'doc': 'the radius to set',
                                                                   'type': 'float'}},
                                            'args': [('radius',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nsets a radius on each point of the mesh for collision purposes. The bigger the radius/thickness, the more easily things collide.',
                                            'inArgs': ['radius'],
                                            'inverse': ('getThickness',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'radius': []},
                                            'types': {'radius': 'float'}},
                                           {'argInfo': {'radius': {'doc': 'the radius to set',
                                                                   'type': 'float'}},
                                            'args': [('radius',
                                                      'float',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nsets a radius (thickness) on a per point basis for the mesh for collision purposes. The bigger the radius, the more easily things collide.',
                                            'inArgs': ['radius'],
                                            'inverse': ('getThickness',
                                                        True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'radius': ['*']},
                                            'types': {'radius': 'float'}}],
                          'setTopology': [{'argInfo': {'edges': {'doc': 'an array containing the edge description. Each element is a vertex index.',
                                                                 'type': 'int'},
                                                       'faces': {'doc': 'an array containing the actual face description. Each element is a vertex index. ',
                                                                 'type': 'int'},
                                                       'numEdges': {'doc': 'number of edges ',
                                                                    'type': 'int'},
                                                       'numFaces': {'doc': 'number of faces ',
                                                                    'type': 'int'},
                                                       'numVertsPerFace': {'doc': 'an array of size numFaces, where each element describes the number of verts on that face ',
                                                                           'type': 'int'}},
                                           'args': [('numFaces',
                                                     'int',
                                                     'in'),
                                                    ('numVertsPerFace',
                                                     'int',
                                                     'in'),
                                                    ('faces',
                                                     'int',
                                                     'in'),
                                                    ('numEdges',
                                                     'int',
                                                     'in'),
                                                    ('edges',
                                                     'int',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nsets the topology of the underlying N Object. Before calling other methods, this must be the first method you call once the rigid object is created.',
                                           'inArgs': ['numFaces',
                                                      'numVertsPerFace',
                                                      'faces',
                                                      'numEdges',
                                                      'edges'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'edges': ['*'],
                                                              'faces': ['*'],
                                                              'numEdges': ['const'],
                                                              'numFaces': ['const'],
                                                              'numVertsPerFace': ['*']},
                                           'types': {'edges': 'int',
                                                     'faces': 'int',
                                                     'numEdges': 'int',
                                                     'numFaces': 'int',
                                                     'numVertsPerFace': 'int'}}],
                          'setVelocities': [{'argInfo': {'velocities': {'doc': 'the array containing the velocity information',
                                                                        'type': 'MFloatPointArray'}},
                                             'args': [('velocities',
                                                       'MFloatPointArray',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSets the velocities of the vertices of the underlying nRigid object',
                                             'inArgs': ['velocities'],
                                             'inverse': ('getVelocities',
                                                         True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'velocities': ['const',
                                                                               '&']},
                                             'types': {'velocities': 'MFloatPointArray'}}]},
              'pymelEnums': {}},
  'MnSolver': {'enums': {},
               'methods': {'addNObject': [{'argInfo': {'obj': {'doc': 'Nucleus object.',
                                                               'type': 'MnObject'}},
                                           'args': [('obj',
                                                     'MnObject',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nAssign the nucleus object to be solved by this solver.',
                                           'inArgs': ['obj'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'obj': ['*']},
                                           'types': {'obj': 'MnObject'}}],
                           'createNSolver': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nCreates the underlying Maya solver object and sets this class to wrap it.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                           'makeAllCollide': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '\nAllow all the objects assigned to the Maya solver object to collide.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                           'removeAllCollisions': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': '\nRemove the collisions between all the objects assigned to the Maya solver object.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                           'removeNObject': [{'argInfo': {'obj': {'doc': 'Nucleus object.',
                                                                  'type': 'MnObject'}},
                                              'args': [('obj',
                                                        'MnObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nRemove the nucleus object from being solved by this solver.',
                                              'inArgs': ['obj'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'obj': ['*']},
                                              'types': {'obj': 'MnObject'}}],
                           'setAirDensity': [{'argInfo': {'dens': {'doc': 'New density value.',
                                                                   'type': 'float'}},
                                              'args': [('dens',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSets the air Density for the solver',
                                              'inArgs': ['dens'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'dens': []},
                                              'types': {'dens': 'float'}}],
                           'setDisabled': [{'argInfo': {'disabled': {'doc': 'True to disable the solver, false to re-enable it.',
                                                                     'type': 'bool'}},
                                            'args': [('disabled',
                                                      'bool',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nDisables the solver - or re-enables it again',
                                            'inArgs': ['disabled'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'disabled': []},
                                            'types': {'disabled': 'bool'}}],
                           'setGravity': [{'argInfo': {'grav': {'doc': 'New gravity value.',
                                                                'type': 'float'}},
                                           'args': [('grav',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSets the gravity magnitude for the objects being solved. Note the the objects should already be added to the solver when applying gravity',
                                           'inArgs': ['grav'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'grav': []},
                                           'types': {'grav': 'float'}}],
                           'setGravityDir': [{'argInfo': {'gravX': {'doc': 'X coordinate of new gravity direction. ',
                                                                    'type': 'float'},
                                                          'gravY': {'doc': 'Y coordinate of new gravity direction. ',
                                                                    'type': 'float'},
                                                          'gravZ': {'doc': 'Z coordinate of new gravity direction.',
                                                                    'type': 'float'}},
                                              'args': [('gravX',
                                                        'float',
                                                        'in'),
                                                       ('gravY',
                                                        'float',
                                                        'in'),
                                                       ('gravZ',
                                                        'float',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': '\nSets the gravity direction for the underlying Maya solver object.',
                                              'inArgs': ['gravX',
                                                         'gravY',
                                                         'gravZ'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'gravX': [],
                                                                 'gravY': [],
                                                                 'gravZ': []},
                                              'types': {'gravX': 'float',
                                                        'gravY': 'float',
                                                        'gravZ': 'float'}}],
                           'setMaxIterations': [{'argInfo': {'maxIter': {'doc': 'New maximum number of iterations to use.',
                                                                         'type': 'int'}},
                                                 'args': [('maxIter',
                                                           'int',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': '\nSet the max number of collision iterations used by the solver',
                                                 'inArgs': ['maxIter'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'maxIter': []},
                                                 'types': {'maxIter': 'int'}}],
                           'setStartTime': [{'argInfo': {'startTime': {'doc': 'New start time.',
                                                                       'type': 'float'}},
                                             'args': [('startTime',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSets the start Time in seconds for the solver',
                                             'inArgs': ['startTime'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'startTime': []},
                                             'types': {'startTime': 'float'}}],
                           'setSubsteps': [{'argInfo': {'substeps': {'doc': 'New number of substeps to use.',
                                                                     'type': 'int'}},
                                            'args': [('substeps',
                                                      'int',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': '\nSet the number of substeps used by the solver',
                                            'inArgs': ['substeps'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'substeps': []},
                                            'types': {'substeps': 'int'}}],
                           'setWindDir': [{'argInfo': {'windX': {'doc': 'X coordinate of new wind direction. ',
                                                                 'type': 'float'},
                                                       'windY': {'doc': 'Y coordinate of new wind direction. ',
                                                                 'type': 'float'},
                                                       'windZ': {'doc': 'Z coordinate of new wind direction.',
                                                                 'type': 'float'}},
                                           'args': [('windX',
                                                     'float',
                                                     'in'),
                                                    ('windY',
                                                     'float',
                                                     'in'),
                                                    ('windZ',
                                                     'float',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': '\nSets the wind direction for the underlying Maya solver object.',
                                           'inArgs': ['windX',
                                                      'windY',
                                                      'windZ'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'windX': [],
                                                              'windY': [],
                                                              'windZ': []},
                                           'types': {'windX': 'float',
                                                     'windY': 'float',
                                                     'windZ': 'float'}}],
                           'setWindNoiseIntensity': [{'argInfo': {'noise': {'doc': 'New wind noise intensity.',
                                                                            'type': 'float'}},
                                                      'args': [('noise',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': '\nSets the wind noise intensity for the underlying Maya solver object.',
                                                      'inArgs': ['noise'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'noise': []},
                                                      'types': {'noise': 'float'}}],
                           'setWindSpeed': [{'argInfo': {'speed': {'doc': 'New wind speed.',
                                                                   'type': 'float'}},
                                             'args': [('speed',
                                                       'float',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '\nSets the wind magnitude for the underlying Maya solver object.',
                                             'inArgs': ['speed'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'speed': []},
                                             'types': {'speed': 'float'}}],
                           'solve': [{'argInfo': {'solveTime': {'doc': 'Time to solve up to.',
                                                                'type': 'float'}},
                                      'args': [('solveTime',
                                                'float',
                                                'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': '\nSolve from the last eval time until the specified time (in seconds).',
                                      'inArgs': ['solveTime'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {'solveTime': []},
                                      'types': {'solveTime': 'float'}}]},
               'pymelEnums': {}}})